Exemple #1
0
def find_source_lines(obj):
    """Find the line number in a file where an object was defined.

    This is essentially a robust wrapper around `inspect.getsourcelines`.

    Returns None if no file can be found.

    Parameters
    ----------
    obj : any Python object

    Returns
    -------
    lineno : int
      The line number where the object definition starts.
    """
    # get source if obj was decorated with @decorator
    if safe_hasattr(obj, "__wrapped__"):
        obj = obj.__wrapped__

    try:
        try:
            lineno = inspect.getsourcelines(obj)[1]
        except TypeError:
            # For instances, try the class object like getsource() does
            if hasattr(obj, "__class__"):
                lineno = inspect.getsourcelines(obj.__class__)[1]
            else:
                lineno = None
    except:  # pylint:disable=bare-except
        return None

    return lineno
Exemple #2
0
    def _load_functions(self):
        """ Loads the run-/build-/init-functions """
        import os
        import inspect
        from importlib.machinery import SourceFileLoader
        if self.definition.get('is_tensorrt_engine'):
            self.__initialized = False
            self._initfunction = self.tensorrt_init
            self._flowfunction = self.tensorrt_run
            self.engine_file = self.definition['path']
        elif self.definition.get('is_autogenerated'):
            self.__initialized = True
            self._initfunction = lambda x, y, z: None
            self._flowfunction = self.worldadapter_flowfunction
        else:
            sourcefile = self.definition['path']
            modulename = 'nodetypes.' + self.definition['category'].replace('/', '.') + os.path.basename(sourcefile)[:-3]
            module = SourceFileLoader(modulename, sourcefile).load_module()

            if self.definition.get('init_function_name'):
                self._initfunction = getattr(module, self.definition['init_function_name'])
                self.__initialized = False
            else:
                self._initfunction = lambda x, y, z: None
                self.__initialized = True

            if self.implementation == 'python':
                self._flowfunction = getattr(module, self.definition['run_function_name'])
                self.line_number = inspect.getsourcelines(self._flowfunction)[1]
            else:
                self._buildfunction = getattr(module, self.definition['build_function_name'])
                self.line_number = inspect.getsourcelines(self._buildfunction)[1]
Exemple #3
0
def _get_custom_pkg_info(name, fn):
    """Retrieve information about the installed package from the install function.
    """
    vals = dict((k, v) for k, v in inspect.getmembers(fn))
    code = inspect.getsourcelines(fn)
    if vals["__name__"] == "decorator":
        fn = [x for x in fn.func_closure if not isinstance(x.cell_contents, str)][0].cell_contents
        vals = dict((k, v) for k, v in inspect.getmembers(fn))
        code = inspect.getsourcelines(fn)
    version = ""
    for line in (l.strip() for l in code[0]):
        if line.find("version") >= 0 and line.find(" =") > 0:
            version = line.split()[-1].replace('"', '').replace("'", "")
        if version:
            break
    doc = vals.get("func_doc", "")
    descr, homepage = "", ""
    if doc is not None:
        descr = doc.split("\n")[0]
        for line in doc.split("\n"):
            if line.strip().startswith("http"):
                homepage = line.strip()
    return {"name": name.replace("install_", ""),
            "description": descr,
            "homepage_uri": homepage,
            "version": version}
Exemple #4
0
def _analyzeGens(top, absnames):
    genlist = []
    for g in top:
        if isinstance(g, _UserCode):
            tree = g
        elif isinstance(g, (_AlwaysComb, _AlwaysSeq, _Always)):
            f = g.func
            s = inspect.getsource(f)
            s = _dedent(s)
            tree = ast.parse(s)
            #print ast.dump(tree)
            tree.sourcefile  = inspect.getsourcefile(f)
            tree.lineoffset = inspect.getsourcelines(f)[1]-1
            tree.symdict = f.func_globals.copy()
            tree.callstack = []
            # handle free variables
            tree.nonlocaldict = {}
            if f.func_code.co_freevars:
                for n, c in zip(f.func_code.co_freevars, f.func_closure):
                    obj = _cell_deref(c)
                    if isinstance(g, _AlwaysComb):
                        if not ( isinstance(obj, (int, long, EnumType,_Signal)) or \
                                 _isMem(obj) or _isTupleOfInts(obj)
                               ):
                            info =  "File %s, line %s: " % (tree.sourcefile, tree.lineoffset)
                            print type(obj)
                            raise ConversionError(_error.UnsupportedType, n, info)
                    tree.symdict[n] = obj
                    # currently, only intbv as automatic nonlocals (until Python 3.0)
                    if isinstance(obj, intbv):
                        tree.nonlocaldict[n] = obj
            tree.name = absnames.get(id(g), str(_Label("BLOCK"))).upper()
            v = _FirstPassVisitor(tree)
            v.visit(tree)
            if isinstance(g, _AlwaysComb):
                v = _AnalyzeAlwaysCombVisitor(tree, g.senslist)
            elif isinstance(g, _AlwaysSeq):
                v = _AnalyzeAlwaysSeqVisitor(tree, g.senslist, g.reset, g.sigregs, g.varregs)
            else:
                v = _AnalyzeAlwaysDecoVisitor(tree, g.senslist)
            v.visit(tree)
        else: # @instance
            f = g.gen.gi_frame
            s = inspect.getsource(f)
            s = _dedent(s)
            tree = ast.parse(s)
            # print ast.dump(tree)
            tree.sourcefile = inspect.getsourcefile(f)
            tree.lineoffset = inspect.getsourcelines(f)[1]-1
            tree.symdict = f.f_globals.copy()
            tree.symdict.update(f.f_locals)
            tree.nonlocaldict = {}
            tree.callstack = []
            tree.name = absnames.get(id(g), str(_Label("BLOCK"))).upper()
            v = _FirstPassVisitor(tree)
            v.visit(tree)
            v = _AnalyzeBlockVisitor(tree)
            v.visit(tree)
        genlist.append(tree)
    return genlist
Exemple #5
0
def action(args):
    qadata = qa_from_csv(qafile)
    
    if args.qa_file:
        print(path.abspath(qafile))
    elif args.variables:
        _, d = qadata.popitem()
        print('\n'.join(d.keys()))
    elif args.names:
        cmpnd_codes = dict(COMPOUND_CODES)
        writer = csv.writer(sys.stdout, quoting=csv.QUOTE_NONNUMERIC)
        writer.writerow(['id', 'code', 'name'])
        for compound_id, d in qadata.items():
            writer.writerow([compound_id,
                             cmpnd_codes[compound_id],
                             d['qa_compound']])
    elif args.compound_id:
        try:
            for k,v in qadata[args.compound_id].items():
                print('%s = %s' % (k,v))
        except KeyError:
            print('"%s" is not a valid compound id; try listing compounds using the "-n/--names" option' % args.compound_id)
            sys.exit(1)
    elif args.list_calculations:
        for name, description in all_checks.items():
            print '%-20s %s' % (name, description)
    elif args.show_calculation:
        fun = getattr(calculations, args.show_calculation)
        print ''.join(inspect.getsourcelines(fun)[0])
    elif args.controls:
        for row in CONTROL_NAMES:
            print '%s\t%s' % row
    elif args.algorithm:
        print ''.join(inspect.getsourcelines(calculations.results)[0])
Exemple #6
0
    def pfile(self,obj,oname=''):
        """Show the whole file where an object was defined."""

        try:
            try:
                lineno = inspect.getsourcelines(obj)[1]
            except TypeError:
                # For instances, try the class object like getsource() does
                if hasattr(obj,'__class__'):
                    lineno = inspect.getsourcelines(obj.__class__)[1]
                    # Adjust the inspected object so getabsfile() below works
                    obj = obj.__class__
        except:
            self.noinfo('file',oname)
            return

        # We only reach this point if object was successfully queried
        
        # run contents of file through pager starting at line
        # where the object is defined
        ofile = inspect.getabsfile(obj)

        if ofile.endswith(('.so', '.dll', '.pyd')):
            print 'File %r is binary, not printing.' % ofile
        elif not os.path.isfile(ofile):
            print 'File %r does not exist, not printing.' % ofile
        else:
            # Print only text files, not extension binaries.  Note that
            # getsourcelines returns lineno with 1-offset and page() uses
            # 0-offset, so we must adjust.
            page.page(self.format(open(ofile).read()),lineno-1)
Exemple #7
0
def _extract_methods_info(module):
    """Extract methods data from a given python modules."""

    categories = [('uncategorized', -1)]
    categories += [
        (line.strip().replace(_CATEGORY_TAG, ''), line_number)
        for line_number, line in enumerate(inspect.getsourcelines(module)[0])
        if line.strip().startswith(_CATEGORY_TAG)]

    methods = [getattr(module, name) for name in dir(module)]
    methods = [method for method in methods if (
        callable(method) and hasattr(method, '__module__') and
        method.__module__ == module.__name__ and method.__name__ != 'run')]
    methods_info = []
    for method in methods:
        codelines, line_number = inspect.getsourcelines(method)
        methods_info.append({
            'name': method.__name__,
            'doc': method.__doc__.strip() if method.__doc__ else '',
            'codelines': [
                line for line in codelines if line.strip() and
                '"""' not in line],
            'method': method,
            'category': [
                category_name for category_name, category_line_number in
                categories if line_number > category_line_number][-1],
        })
    return methods_info
    def getSchemaForContentType(self):
        result = OrderedDict()
        schema = self.context.Schema()

        field_ids = schema.keys()
        field_ids.sort()

        for i in field_ids:
            field = schema[i]
            widget = field.widget
            field_py_file = inspect.getsourcefile(field.__class__)
            field_py_lineno = inspect.getsourcelines(field.__class__)[1]

            widget_py_file = inspect.getsourcefile(widget.__class__)
            widget_py_lineno = inspect.getsourcelines(widget.__class__)[1]

            label = widget.label

            condition = widget.getCondition()
            visibility = widget.visible

            result[i] = {'field' : field.__class__.__name__,
                         'field_py_file' : field_py_file,
                         'field_py_lineno' : field_py_lineno,
                         'widget' : widget.__class__.__name__,
                         'widget_py_file' : widget_py_file,
                         'widget_py_lineno' : widget_py_lineno,
                         'label' : label,
                         'condition' : condition,
                         'visibility' : visibility,}


        return result
Exemple #9
0
def find_source_lines(obj):
    """Find the line number in a file where an object was defined.

    This is essentially a robust wrapper around `inspect.getsourcelines`.

    Returns None if no file can be found.

    Parameters
    ----------
    obj : any Python object

    Returns
    -------
    lineno : int
      The line number where the object definition starts.
    """
    obj = _get_wrapped(obj)
    
    try:
        try:
            lineno = inspect.getsourcelines(obj)[1]
        except TypeError:
            # For instances, try the class object like getsource() does
            if hasattr(obj, '__class__'):
                lineno = inspect.getsourcelines(obj.__class__)[1]
            else:
                lineno = None
    except:
        return None

    return lineno
Exemple #10
0
def print_infos(solver):
    print('Model: \n%s' % solver.model)

    print('Solver: \n%s' % solver)

    print('Data Augmentation Function: \n')
    print(''.join(['\t' + i for i in inspect.getsourcelines(data_augm)[0]]))
    print('Custom Weight Decay Update Rule: \n')
    print(''.join(['\t' + i for i in inspect.getsourcelines(custom_update_decay)[0]]))
def write_user_exception(filename, stream_err_output, num_lines_offset_trace=0):
    import sys
    import traceback
    import inspect
    (t, v, tb) = sys.exc_info()
    name = t.__name__
    record_error = False

    if name in ['SyntaxError', 'IndentationError']:
        syntax_error_values = v.args
        user_line_number = syntax_error_values[1][1] - num_lines_offset_trace
        error_message =  "%s: %s\n\tFile: %s, line %s column %s\n\t%s" % \
                                    (name,
                                     syntax_error_values[0],
                                     syntax_error_values[1][0],
                                     user_line_number,
                                     syntax_error_values[1][2],
                                     syntax_error_values[1][3])
    else:
        error_message = "%s: %s\n" % (name, v)
        user_line_number = None
        while 1:
            e_file_name = tb.tb_frame.f_code.co_filename
            if e_file_name.find(filename) > 0:
                record_error = True
            if not record_error:
                if not tb.tb_next:
                    break
                tb = tb.tb_next
                continue

            line_number = tb.tb_lineno
            mod = inspect.getmodule(tb)
            if mod:
                lines, offset = inspect.getsourcelines(mod)
                line = lines[line_number - offset - 1]
            else:
                #Useful to catch exceptions with an invalid module (like syntax
                #errors)
                lines, offset = inspect.getsourcelines(tb.tb_frame)
                if (line_number - 1) >= len(lines):
                    line = "Unknown Line"
                else:
                    line = lines[line_number - 1]

            user_line_number = line_number - num_lines_offset_trace
            func_name = tb.tb_frame.f_code.co_name
            error_message += 'File %s, line %s, in %s\n\t%s\n' % \
                                (e_file_name, user_line_number, func_name, line)
            if not tb.tb_next:
                break
            tb = tb.tb_next
        if name in ['UnicodeEncodeError']:
            error_message += "\nTo print a unicode string in your udf use encode('utf-8').  Example: \n\tprint 'Example'.encode('utf-8')"  
    if user_line_number:
        stream_err_output.write("%s\n" % user_line_number)
    stream_err_output.write("%s\n" % error_message)
def testcollect( globs,
                 matchfun = lambda x: re.match( 'test', x)):
    from inspect import getfile, getsourcelines
    result = [x[ 1]
              for x in globs.items()
              if callable( x[ 1]) and matchfun( x[ 0])]
    result.sort( lambda x, y: cmp( (getfile( x), getsourcelines( x)[ -1]),
                                   (getfile( y), getsourcelines( y)[ -1])))
    return result
    def ok_to_add_method(self, member, parent):
        if inspect.getsourcefile(member) != inspect.getsourcefile(parent):
            return False

        # Use line inspection to work out whether the method is defined on this
        # klass. Possibly not the best way, but I can't think of another atm.
        lines, start_line = inspect.getsourcelines(member)
        parent_lines, parent_start_line = inspect.getsourcelines(parent)
        if start_line < parent_start_line or start_line > parent_start_line + len(parent_lines):
            return False
        return True
def _analyzeGens(top, absnames):
    genlist = []
    for g in top:
        if isinstance(g, _UserCode):
            ast = g
        elif isinstance(g, (_AlwaysComb, _Always)):
            f = g.func
            s = inspect.getsource(f)
            # remove decorators
            s = re.sub(r"@.*", "", s)
            s = s.lstrip()
            ast = compiler.parse(s)
            # print ast
            ast.sourcefile = inspect.getsourcefile(f)
            ast.lineoffset = inspect.getsourcelines(f)[1]-1
            ast.symdict = f.func_globals.copy()
            ast.callstack = []
            # handle free variables
            if f.func_code.co_freevars:
                for n, c in zip(f.func_code.co_freevars, f.func_closure):
                    obj = _cell_deref(c)
                    if isinstance(g, _AlwaysComb):
                        # print type(obj)
                        assert isinstance(obj, (int, long, Signal)) or \
                               _isMem(obj) or _isTupleOfInts(obj)
                    ast.symdict[n] = obj
            ast.name = absnames.get(id(g), str(_Label("BLOCK"))).upper()
            v = _NotSupportedVisitor(ast)
            compiler.walk(ast, v)
            if isinstance(g, _AlwaysComb):
                v = _AnalyzeAlwaysCombVisitor(ast, g.senslist)
            else:
                v = _AnalyzeAlwaysDecoVisitor(ast, g.senslist)
            compiler.walk(ast, v)
        else: # @instance
            f = g.gen.gi_frame
            s = inspect.getsource(f)
            # remove decorators
            s = re.sub(r"@.*", "", s)
            s = s.lstrip()
            ast = compiler.parse(s)
            # print ast
            ast.sourcefile = inspect.getsourcefile(f)
            ast.lineoffset = inspect.getsourcelines(f)[1]-1
            ast.symdict = f.f_globals.copy()
            ast.symdict.update(f.f_locals)
            ast.callstack = []
            ast.name = absnames.get(id(g), str(_Label("BLOCK"))).upper()
            v = _NotSupportedVisitor(ast)
            compiler.walk(ast, v)
            v = _AnalyzeBlockVisitor(ast)
            compiler.walk(ast, v)
        genlist.append(ast)
    return genlist
Exemple #15
0
    def source(self):
        fsource = inspect.getsourcelines(self.f)[0][2:]
        fsource = textwrap.dedent(''.join(fsource))
        # find other functions defined in same module (e.g. plotting helpers)
        for k, v in self.f.func_globals.iteritems():
            if hasattr(v, '__module__') and v.__module__ == self.f.__module__:
                # and if they are mentioned in the source code, list them, too.
                if k in fsource:
                    fsource = textwrap.dedent(''.join(inspect.getsourcelines(v)[0])) + '\n' + fsource
        preamble = '# Note that this code might not run if you directly copy and paste it:\n# - Not all import statements are shown here\n# - `self` is a reference to a test instance, which allows access to\n#   parameters such as the directory where the test is run etc.\n\n'

        return preamble + fsource
Exemple #16
0
 def checksum(self):
     if not self._checksum:
         m = hashlib.sha1()
         for ia in full_traverse(self.input_args):
             if isinstance(ia, target.Target):
                 m.update(ia.checksum())
             else:
                 m.update(joblib.hash(ia).encode())
         m.update('\n'.join(inspect.getsourcelines(self.user_outputs)[0]).encode('utf-8'))
         m.update('\n'.join(inspect.getsourcelines(self.user_run)[0]).encode('utf-8'))
         self._checksum = m.hexdigest()
     return self._checksum
 def wrapper(*args, **kwargs):
     if self._debug:
         trace_obj = {
             'name': func.__name__,
             'documentation': inspect.getdoc(func),
             'file': inspect.getfile(func),
             'source_code': inspect.getsourcelines(func)[0],
             'source_line': inspect.getsourcelines(func)[1],
             'module': inspect.getmodule(func).__name__,
             'call_timestamp': time.time()
         }
         self._trace.append(trace_obj)
     return func(*args, **kwargs)
        def registrator(cfunc):
            """Register function as handler for pattern in corresponded map.
            
            Also, bind default func arguments.
            """
            
            # Extract original function.
            if hasattr(cfunc, '__decorated__'):
                func = getattr(cfunc, '__decorated__')
            else:
                func = cfunc
            
            # Get the names and default values of a function's arguments.
            func_args, func_varargs, func_varkw, func_defaults = inspect.getargspec(func)
            
            func_bindings = {}
            
            if func_defaults is not None:
                # Populate func bindings with default function values.
                def assign_default_values(tree, values):
                    for el in tree:
                        value = values.next()
                        if type(el) == types.ListType:
                            assign_default_values(el, iter(value))
                        else:
                            func_bindings[el] = Value(value)
                assign_default_values(func_args[-len(func_defaults):], iter(func_defaults))
            
            # Merge func bindings with step definition bindings.
            func_bindings.update(bindings)
            
            # Show warnings.
            if self.verbose:
                if func_varargs in func_bindings:
                    sys.stderr.write(
                        "%s:%d : "
                        "WARNING! You've used name of positional argument for bindings: '*%s'." 
                        "Did you really want this?\n" \
                        % (inspect.getsourcefile(func), inspect.getsourcelines()[1], func_varargs)
                    )
                if func_varkw in func_bindings:
                    sys.stderr.write(
                        "%s:%d : "
                        "WARNING! You've used name of keyword argument for bindings: '**%s'." 
                        "Did you really want this?\n" \
                        % (inspect.getsourcefile(func), inspect.getsourcelines()[1], func_varargs)
                    )
            
            patterns[pattern] = (cfunc, func_args, func_bindings)

            return cfunc
Exemple #19
0
def linkcode_resolve(domain, info):
    """A simple function to find matching source code."""
    module_name = info["module"]
    fullname = info["fullname"]
    attribute_name = fullname.split(".")[-1]
    base_url = "https://github.com/JelteF/PyLaTeX/"

    if "+" in version:
        commit_hash = version.split(".")[-1][1:]
        base_url += "tree/%s/" % commit_hash
    else:
        base_url += "blob/v%s/" % version

    filename = module_name.replace(".", "/") + ".py"
    module = sys.modules.get(module_name)

    # Get the actual object
    try:
        actual_object = module
        for obj in fullname.split("."):
            parent = actual_object
            actual_object = getattr(actual_object, obj)
    except AttributeError:
        return None

    # Fix property methods by using their getter method
    if isinstance(actual_object, property):
        actual_object = actual_object.fget

    # Try to get the linenumber of the object
    try:
        source, start_line = inspect.getsourcelines(actual_object)
    except TypeError:
        # If it can not be found, try to find it anyway in the parents its
        # source code
        parent_source, parent_start_line = inspect.getsourcelines(parent)
        for i, line in enumerate(parent_source):
            if line.strip().startswith(attribute_name):
                start_line = parent_start_line + i
                end_line = start_line
                break
        else:
            return None

    else:
        end_line = start_line + len(source) - 1

    line_anchor = "#L%d-L%d" % (start_line, end_line)

    return base_url + filename + line_anchor
Exemple #20
0
def linkcode_resolve(domain, info):
    """A simple function to find matching source code."""
    module_name = info['module']
    fullname = info['fullname']
    attribute_name = fullname.split('.')[-1]
    base_url = 'https://github.com/JelteF/PyLaTeX/blob/'

    if release.endswith('-dev'):
        base_url += 'master/'
    else:
        base_url += 'v' + version + '/'

    filename = module_name.replace('.', '/') + '.py'
    module = sys.modules.get(module_name)

    # Get the actual object
    try:
        actual_object = module
        for obj in fullname.split('.'):
            parent = actual_object
            actual_object = getattr(actual_object, obj)
    except AttributeError:
        return None

    # Fix property methods by using their getter method
    if isinstance(actual_object, property):
        actual_object = actual_object.fget

    # Try to get the linenumber of the object
    try:
        source, start_line = inspect.getsourcelines(actual_object)
    except TypeError:
        # If it can not be found, try to find it anyway in the parents its
        # source code
        parent_source, parent_start_line = inspect.getsourcelines(parent)
        for i, line in enumerate(parent_source):
            if line.strip().startswith(attribute_name):
                start_line = parent_start_line + i
                end_line = start_line
                break
        else:
            return None

    else:
        end_line = start_line + len(source) - 1

    line_anchor = '#L%d-L%d' % (start_line, end_line)

    return base_url + filename + line_anchor
Exemple #21
0
    def source(self):
        import inspect
        import itertools

        lines = inspect.getsourcelines(self.__class__)[0]
        lines = [x for x in itertools.takewhile(lambda x: not x.strip().startswith('template'), lines)]
        return ''.join(lines)
Exemple #22
0
    def _template_decorator(self, func):
        """Registers template as expected by _create_template_function.

        The template data consists of:
        - the function object as it comes from the sandbox evaluation of the
          template declaration.
        - its code, modified as described in the comments of this method.
        - the path of the file containing the template definition.
        """

        if not inspect.isfunction(func):
            raise Exception('`template` is a function decorator. You must '
                'use it as `@template` preceding a function declaration.')

        name = func.func_name

        if name in self.templates:
            raise KeyError(
                'A template named "%s" was already declared in %s.' % (name,
                self.templates[name][2]))

        if name.islower() or name.isupper() or name[0].islower():
            raise NameError('Template function names must be CamelCase.')

        lines, firstlineno = inspect.getsourcelines(func)
        first_op = None
        generator = tokenize.generate_tokens(iter(lines).next)
        # Find the first indent token in the source of this template function,
        # which corresponds to the beginning of the function body.
        for typ, s, begin, end, line in generator:
            if typ == tokenize.OP:
                first_op = True
            if first_op and typ == tokenize.INDENT:
                break
        if typ != tokenize.INDENT:
            # This should never happen.
            raise Exception('Could not find the first line of the template %s' %
                func.func_name)
        # The code of the template in moz.build looks like this:
        # m      def Foo(args):
        # n          FOO = 'bar'
        # n+1        (...)
        #
        # where,
        # - m is firstlineno - 1,
        # - n is usually m + 1, but in case the function signature takes more
        # lines, is really m + begin[0] - 1
        #
        # We want that to be replaced with:
        # m       if True:
        # n           FOO = 'bar'
        # n+1         (...)
        #
        # (this is simpler than trying to deindent the function body)
        # So we need to prepend with n - 1 newlines so that line numbers
        # are unchanged.
        code = '\n' * (firstlineno + begin[0] - 3) + 'if True:\n'
        code += ''.join(lines[begin[0] - 1:])

        self.templates[name] = func, code, self._context.current_path
Exemple #23
0
    def view_info(self, discr, context, request, content):
        introspector = request.registry.introspector

        template = 'unknown'
        intr = introspector.get('templates', discr)
        if intr is not None: # pragma: no cover
            template = intr['name']

        intr = introspector.get('views', discr)
        if intr is None: # pragma: no cover
            return content

        view = intr['callable']

        data = OrderedDict(
            (('name', intr['name']),
             ('route-name', intr['route_name']),
             ('view-factory', '%s.%s'%(view.__module__, view.__name__)),
             ('python-module', inspect.getmodule(view).__name__),
             ('python-module-location', inspect.getsourcefile(view)),
             ('python-module-line', inspect.getsourcelines(view)[-1]),
             ('renderer', template),
             ('context', '%s.%s'%(context.__class__.__module__,
                                  context.__class__.__name__)),
             ('context-path', request.resource_url(context)),
             ))

        content = text_('\n<!-- view:\n%s \n-->\n'\
                        '<div style="border: 2px solid red">%s</div>')%(
            json.dumps(data, indent=2), content)

        return content
Exemple #24
0
def get_function_attributes(func):
    '''
    Extract the function attributes from a Python function or object with
    *py_func* attribute, such as CPUOverloaded.

    Returns an instance of FunctionAttributes.
    '''
    if hasattr(func, 'py_func'):
        func = func.py_func  # This is a Overload object

    name, filename, lineno = DEFAULT_FUNCTION_ATTRIBUTES
    try:
        name = func.__name__
    except AttributeError:
        pass  # this "function" object isn't really a function

    try:
        possible_filename = inspect.getsourcefile(func)
        # Sometimes getsourcefile returns null
        if possible_filename is not None:
            filename = possible_filename
    except TypeError:
        pass  # built-in function, or other object unsupported by inspect

    try:
        lines, lineno = inspect.getsourcelines(func)
    except (IOError, TypeError):
        pass  # unable to read source code for function

    return FunctionAttributes(name, filename, lineno)
Exemple #25
0
  def _try_waiter (self, entry):
    """
    Tries a waiting callback.

    Calls the callback, removes from _waiters, and returns True if
    all are satisfied.
    """
    if entry not in self._waiters:
      # Already handled
      return
    callback, name, components, args_, kw_ = entry
    for c in components:
      if not self.hasComponent(c):
        return False
    self._waiters.remove(entry)
    try:
      if callback is not None:
        callback(*args_,**kw_)
    except:
      import traceback
      msg = "Exception while trying to notify " + name
      import inspect
      try:
        msg += " at " + inspect.getfile(callback)
        msg += ":" + str(inspect.getsourcelines(callback)[1])
      except:
        pass
      log.exception(msg)
    return True
Exemple #26
0
 def _get_fileinfo(self, test):
     filename = inspect.getsourcefile(test.method())
     linenum = inspect.getsourcelines(test.method())
     try: # Fixme
         return "%s(%d)"% (os.path.basename(filename), linenum[1])
     except TypeError:
         return str(test.method)
Exemple #27
0
def uncompile(c):
    """ uncompile(codeobj) -> [source, filename, mode, flags, firstlineno, privateprefix] """
    if c.co_flags & inspect.CO_NESTED or c.co_freevars:
        raise Unsupported('nested functions not supported')
    if c.co_name == '<lambda>':
        raise Unsupported('lambda functions not supported')
    if c.co_filename == '<string>':
        raise Unsupported('code without source file not supported')

    filename = inspect.getfile(c)
    try:
        lines, firstlineno = inspect.getsourcelines(c)
    except IOError:
        raise NoSource('source code not available')
    source = ''.join(lines)

    # __X is mangled to _ClassName__X in methods. Find this prefix:
    privateprefix = None
    for name in c.co_names:
        m = re.match('^(_[A-Za-z][A-Za-z0-9_]*)__.*$', name)
        if m:
            privateprefix = m.group(1)
            break

    return [source, filename, 'exec', c.co_flags & PyCF_MASK, firstlineno, privateprefix]
Exemple #28
0
def coderef_role(typ, rawtext, text, lineno, inliner, options={}, content=[]):
    text = utils.unescape(text)
    has_explicit_title, title, target = split_explicit_title(text)
    try:
        modname, name = target.rsplit('.', 1)
    except ValueError:
        raise Exception("Don't know how to import name %s" % target)
    mod = import_module(modname)

    try:
        value = getattr(mod, name, None)
    except AttributeError:
        raise Exception("No name '%s' in module '%s'" % (name, modname))
    #~ raise Exception("20130908 %s " % lines)
    if isinstance(value, type):
        if value.__module__ != modname:
            raise Exception("20130908 %r != %r" % (value.__module__, modname))

    url = srcref(mod)

    lines, line_no = inspect.getsourcelines(value)
    if line_no:
        url += "#" + str(line_no)
    if not has_explicit_title:
        pass
    pnode = nodes.reference(title, title, internal=False, refuri=url)
    return [pnode], []
Exemple #29
0
    def event_filter_to_descriptive_string(self, event_filter):
        """Find the source code of the callable or pretty-print the dictionary"""
        message = ''
        if callable(event_filter):
            file_name = '(unknown)'
            try:
                file_name = inspect.getsourcefile(event_filter)
            except TypeError:
                pass

            try:
                list_of_source_lines, line_no = inspect.getsourcelines(event_filter)
            except IOError:
                pass
            else:
                message = '{file_name}:{line_no}\n{hr}\n{event_filter}\n{hr}'.format(
                    event_filter=''.join(list_of_source_lines).rstrip(),
                    file_name=file_name,
                    line_no=line_no,
                    hr='-' * 20,
                )

        if not message:
            message = '{hr}\n{event_filter}\n{hr}'.format(
                event_filter=pprint.pformat(event_filter),
                hr='-' * 20,
            )

        return message
Exemple #30
0
def dump_garbage(source=False):
    """
    show us what's the garbage about
    """
    import inspect, gc

    print "\nCollecting GARBAGE:"
    gc.collect()
    print "\nCollecting GARBAGE:"
    gc.collect()
    print "\nGARBAGE OBJECTS:"
    for x in gc.garbage:
        try:
            s = str(x)
            if len(s) > 80:
                s = "%s..." % s[:80]
            print "::", s
            print "        type:", type(x)
            print "   referrers:", len(gc.get_referrers(x))
            print "    is class:", inspect.isclass(type(x))
            print "      module:", inspect.getmodule(x)
            if source:
                lines, line_num = inspect.getsourcelines(type(x))
                print "    line num:", line_num
                for l in lines:
                    print "        line:", l.rstrip("\n")

        except:
            pass
Exemple #31
0
def linkcode_resolve(domain, info):
    """Determine the URL corresponding to a Python object.

    Parameters
    ----------
    domain : str
        Only useful when 'py'.
    info : dict
        With keys "module" and "fullname".

    Returns
    -------
    url : str
        The code URL.

    Notes
    -----
    This has been adapted to deal with our "verbose" decorator.

    Adapted from SciPy (doc/source/conf.py).
    """
    import mne
    if domain != 'py':
        return None

    modname = info['module']
    fullname = info['fullname']

    submod = sys.modules.get(modname)
    if submod is None:
        return None

    obj = submod
    for part in fullname.split('.'):
        try:
            obj = getattr(obj, part)
        except Exception:
            return None
    # deal with our decorators properly
    while hasattr(obj, '__wrapped__'):
        obj = obj.__wrapped__

    try:
        fn = inspect.getsourcefile(obj)
    except Exception:
        fn = None
    if not fn:
        try:
            fn = inspect.getsourcefile(sys.modules[obj.__module__])
        except Exception:
            fn = None
    if not fn:
        return None
    fn = op.relpath(fn, start=op.dirname(mne.__file__))
    fn = '/'.join(op.normpath(fn).split(os.sep))  # in case on Windows

    try:
        source, lineno = inspect.getsourcelines(obj)
    except Exception:
        lineno = None

    if lineno:
        linespec = "#L%d-L%d" % (lineno, lineno + len(source) - 1)
    else:
        linespec = ""

    if 'dev' in mne.__version__:
        kind = 'master'
    else:
        kind = 'maint/%s' % ('.'.join(mne.__version__.split('.')[:2]))
    return "http://github.com/mne-tools/mne-python/blob/%s/mne/%s%s" % (  # noqa
        kind, fn, linespec)
Exemple #32
0
    def magic_edit(self, parameter_s='', last_call=['', '']):
        """Bring up an editor and execute the resulting code.

        Usage:
          %edit [options] [args]

        %edit runs IPython's editor hook.  The default version of this hook is
        set to call the __IPYTHON__.rc.editor command.  This is read from your
        environment variable $EDITOR.  If this isn't found, it will default to
        vi under Linux/Unix and to notepad under Windows.  See the end of this
        docstring for how to change the editor hook.

        You can also set the value of this editor via the command line option
        '-editor' or in your ipythonrc file. This is useful if you wish to use
        specifically for IPython an editor different from your typical default
        (and for Windows users who typically don't set environment variables).

        This command allows you to conveniently edit multi-line code right in
        your IPython session.
        
        If called without arguments, %edit opens up an empty editor with a
        temporary file and will execute the contents of this file when you
        close it (don't forget to save it!).


        Options:

        -n <number>: open the editor at a specified line number.  By default,
        the IPython editor hook uses the unix syntax 'editor +N filename', but
        you can configure this by providing your own modified hook if your
        favorite editor supports line-number specifications with a different
        syntax.
        
        -p: this will call the editor with the same data as the previous time
        it was used, regardless of how long ago (in your current session) it
        was.

        -r: use 'raw' input.  This option only applies to input taken from the
        user's history.  By default, the 'processed' history is used, so that
        magics are loaded in their transformed version to valid Python.  If
        this option is given, the raw input as typed as the command line is
        used instead.  When you exit the editor, it will be executed by
        IPython's own processor.
        
        -x: do not execute the edited code immediately upon exit. This is
        mainly useful if you are editing programs which need to be called with
        command line arguments, which you can then do using %run.


        Arguments:

        If arguments are given, the following possibilites exist:

        - The arguments are numbers or pairs of colon-separated numbers (like
        1 4:8 9). These are interpreted as lines of previous input to be
        loaded into the editor. The syntax is the same of the %macro command.

        - If the argument doesn't start with a number, it is evaluated as a
        variable and its contents loaded into the editor. You can thus edit
        any string which contains python code (including the result of
        previous edits).

        - If the argument is the name of an object (other than a string),
        IPython will try to locate the file where it was defined and open the
        editor at the point where it is defined. You can use `%edit function`
        to load an editor exactly at the point where 'function' is defined,
        edit it and have the file be executed automatically.

        If the object is a macro (see %macro for details), this opens up your
        specified editor with a temporary file containing the macro's data.
        Upon exit, the macro is reloaded with the contents of the file.

        Note: opening at an exact line is only supported under Unix, and some
        editors (like kedit and gedit up to Gnome 2.8) do not understand the
        '+NUMBER' parameter necessary for this feature. Good editors like
        (X)Emacs, vi, jed, pico and joe all do.

        - If the argument is not found as a variable, IPython will look for a
        file with that name (adding .py if necessary) and load it into the
        editor. It will execute its contents with execfile() when you exit,
        loading any code in the file into your interactive namespace.

        After executing your code, %edit will return as output the code you
        typed in the editor (except when it was an existing file). This way
        you can reload the code in further invocations of %edit as a variable,
        via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
        the output.

        Note that %edit is also available through the alias %ed.

        This is an example of creating a simple function inside the editor and
        then modifying it. First, start up the editor:

        In [1]: ed
        Editing... done. Executing edited code...
        Out[1]: 'def foo():n    print "foo() was defined in an editing session"n'

        We can then call the function foo():
        
        In [2]: foo()
        foo() was defined in an editing session

        Now we edit foo.  IPython automatically loads the editor with the
        (temporary) file where foo() was previously defined:
        
        In [3]: ed foo
        Editing... done. Executing edited code...

        And if we call foo() again we get the modified version:
        
        In [4]: foo()
        foo() has now been changed!

        Here is an example of how to edit a code snippet successive
        times. First we call the editor:

        In [5]: ed
        Editing... done. Executing edited code...
        hello
        Out[5]: "print 'hello'n"

        Now we call it again with the previous output (stored in _):

        In [6]: ed _
        Editing... done. Executing edited code...
        hello world
        Out[6]: "print 'hello world'n"

        Now we call it with the output #8 (stored in _8, also as Out[8]):

        In [7]: ed _8
        Editing... done. Executing edited code...
        hello again
        Out[7]: "print 'hello again'n"


        Changing the default editor hook:

        If you wish to write your own editor hook, you can put it in a
        configuration file which you load at startup time.  The default hook
        is defined in the IPython.core.hooks module, and you can use that as a
        starting example for further modifications.  That file also has
        general instructions on how to set a new hook for use once you've
        defined it."""

        # FIXME: This function has become a convoluted mess.  It needs a
        # ground-up rewrite with clean, simple logic.

        def make_filename(arg):
            "Make a filename from the given args"
            try:
                filename = get_py_filename(arg)
            except IOError:
                if args.endswith('.py'):
                    filename = arg
                else:
                    filename = None
            return filename

        # custom exceptions
        class DataIsObject(Exception):
            pass

        opts, args = self.parse_options(parameter_s, 'prn:')
        # Set a few locals from the options for convenience:
        opts_p = opts.has_key('p')
        opts_r = opts.has_key('r')

        # Default line number value
        lineno = opts.get('n', None)
        if lineno is not None:
            try:
                lineno = int(lineno)
            except:
                warn("The -n argument must be an integer.")
                return

        if opts_p:
            args = '_%s' % last_call[0]
            if not self.shell.user_ns.has_key(args):
                args = last_call[1]

        # use last_call to remember the state of the previous call, but don't
        # let it be clobbered by successive '-p' calls.
        try:
            last_call[0] = self.shell.displayhook.prompt_count
            if not opts_p:
                last_call[1] = parameter_s
        except:
            pass

        # by default this is done with temp files, except when the given
        # arg is a filename
        use_temp = True

        data = ''
        if args[0].isdigit():
            # Mode where user specifies ranges of lines, like in %macro.
            # This means that you can't edit files whose names begin with
            # numbers this way. Tough.
            ranges = args.split()
            data = ''.join(self.extract_input_slices(ranges, opts_r))
        elif args.endswith('.py'):
            filename = make_filename(args)
            use_temp = False
        elif args:
            try:
                # Load the parameter given as a variable. If not a string,
                # process it as an object instead (below)

                #print '*** args',args,'type',type(args)  # dbg
                data = eval(args, self.shell.user_ns)
                if not isinstance(data, basestring):
                    raise DataIsObject

            except (NameError, SyntaxError):
                # given argument is not a variable, try as a filename
                filename = make_filename(args)
                if filename is None:
                    warn("Argument given (%s) can't be found as a variable "
                         "or as a filename." % args)
                    return
                use_temp = False

            except DataIsObject:
                # macros have a special edit function
                if isinstance(data, Macro):
                    self._edit_macro(args, data)
                    return

                # For objects, try to edit the file where they are defined
                try:
                    filename = inspect.getabsfile(data)
                    if 'fakemodule' in filename.lower() and inspect.isclass(
                            data):
                        # class created by %edit? Try to find source
                        # by looking for method definitions instead, the
                        # __module__ in those classes is FakeModule.
                        attrs = [getattr(data, aname) for aname in dir(data)]
                        for attr in attrs:
                            if not inspect.ismethod(attr):
                                continue
                            filename = inspect.getabsfile(attr)
                            if filename and 'fakemodule' not in filename.lower(
                            ):
                                # change the attribute to be the edit target instead
                                data = attr
                                break

                    datafile = 1
                except TypeError:
                    filename = make_filename(args)
                    datafile = 1
                    warn('Could not find file where `%s` is defined.\n'
                         'Opening a file named `%s`' % (args, filename))
                # Now, make sure we can actually read the source (if it was in
                # a temp file it's gone by now).
                if datafile:
                    try:
                        if lineno is None:
                            lineno = inspect.getsourcelines(data)[1]
                    except IOError:
                        filename = make_filename(args)
                        if filename is None:
                            warn('The file `%s` where `%s` was defined cannot '
                                 'be read.' % (filename, data))
                            return
                use_temp = False

        if use_temp:
            filename = self.shell.mktempfile(data)
            print('IPython will make a temporary file named:', filename)

        # Make sure we send to the client an absolute path, in case the working
        # directory of client and kernel don't match
        filename = os.path.abspath(filename)

        payload = {
            'source': 'IPython.zmq.zmqshell.ZMQInteractiveShell.edit_magic',
            'filename': filename,
            'line_number': lineno
        }
        self.payload_manager.write_payload(payload)
Exemple #33
0
def validate_function(fn: FunctionType, config: Configuration,
                      module_type: ModuleType) -> FunctionValidationResult:
    """Validates the docstring of a function against its signature.

    Args:
        fn (FunctionType): The function to validate.
        config (Configuration): The configuration to use while validating.
        module_type (ModuleType): The module from which the function was extracted.

    Returns:
        FunctionValidationResult: The result of validating this function.
    """
    log(f"Validating function: {fn}")
    result = FunctionValidationResult(fn, module_type)

    doc = inspect.getdoc(fn)
    if not doc:
        if config.fail_on_missing_docstring:
            result.result = ResultType.FAILED
            result.fail_reason = f"Function does not have a docstring"
            _, line_number = inspect.getsourcelines(fn)
            result.range = Range(line_number, line_number, 0, 0)
        else:
            result.result = ResultType.NO_DOC
        return result

    parser = config.get_parser()

    summary = parser.get_summary(doc, module_type)
    if not summary and config.fail_on_missing_summary:
        result.result = ResultType.FAILED
        result.fail_reason = f"Function does not have a summary"
        result.range = __get_docstring_range(fn, module_type, doc)
        return result

    sig = inspect.signature(fn)
    sig_parameters = [
        Parameter(name, proxy.annotation)
        for name, proxy in sig.parameters.items() if name != "self"
    ]
    sig_return_type = type(
        None) if sig.return_annotation is None else sig.return_annotation

    try:
        doc_parameters = parser.get_parameters(doc, module_type)
        doc_return_type = parser.get_return_type(doc, module_type)
    except ParseException as e:
        result.result = ResultType.FAILED
        result.fail_reason = f"Unable to parse docstring: {str(e)}"
        result.range = __get_docstring_range(fn, module_type, doc)
        return result

    # Validate return type
    if sig_return_type != doc_return_type:
        result.result = ResultType.FAILED
        result.fail_reason = f"Return type differ. Expected (from signature) {sig_return_type}, but got (in docs) {doc_return_type}."
        result.range = __get_docstring_range(fn, module_type, doc)
        return result

    # Validate equal number of parameters
    if len(sig_parameters) != len(doc_parameters):
        result.result = ResultType.FAILED
        result.fail_reason = f"Number of arguments differ. Expected (from signature) {len(sig_parameters)} arguments, but found (in docs) {len(doc_parameters)}."
        result.range = __get_docstring_range(fn, module_type, doc)
        return result

    # Validate name and type of function parameters
    for sigparam, docparam in zip(sig_parameters, doc_parameters):
        if sigparam.name != docparam.name:
            result.result = ResultType.FAILED
            result.fail_reason = f"Argument name differ. Expected (from signature) '{sigparam.name}', but got (in docs) '{docparam.name}'"
            result.range = __get_docstring_range(fn, module_type, doc)
            return result

        # NOTE: Optional[str] == Union[str, None] # True
        if sigparam.type != docparam.type:
            result.result = ResultType.FAILED
            result.fail_reason = f"Argument type differ. Argument '{sigparam.name}' was expected (from signature) to have type '{sigparam.type}', but has (in docs) type '{docparam.type}'"
            result.range = __get_docstring_range(fn, module_type, doc)
            return result

    # Validate exceptions raised
    if config.fail_on_raises_section:
        try:
            sig_exceptions = get_exceptions_raised(fn, module_type)
            doc_exceptions = parser.get_exceptions_raised(doc)

            if len(sig_exceptions) != len(doc_exceptions):
                result.result = ResultType.FAILED
                result.fail_reason = f"Number of listed raised exceptions does not match actual. Doc: {doc_exceptions}, expected: {sig_exceptions}"
                result.range = __get_docstring_range(fn, module_type, doc)
                return result

            intersection = set(sig_exceptions) - set(doc_exceptions)
            if len(intersection) > 0:
                result.result = ResultType.FAILED
                result.fail_reason = f"Listed raised exceptions does not match actual. Docstring: {doc_exceptions}, expected: {sig_exceptions}"
                result.range = __get_docstring_range(fn, module_type, doc)
                return result
        except ParseException as e:
            result.result = ResultType.FAILED
            result.fail_reason = f"Unable to parse docstring: {str(e)}"
            result.range = __get_docstring_range(fn, module_type, doc)
            return result

    result.result = ResultType.OK
    return result
Exemple #34
0
    def run(self, opts):
        from calibre.utils.serialize import msgpack_dumps
        scripts = {}
        for x in ('console', 'gui'):
            for name in basenames[x]:
                if name in ('calibre-complete', 'calibre_postinstall'):
                    continue
                scripts[name] = x

        dest = self.j(self.RESOURCES, 'scripts.calibre_msgpack')
        if self.newer(dest, self.j(self.SRC, 'calibre', 'linux.py')):
            self.info('\tCreating ' + self.b(dest))
            with open(dest, 'wb') as f:
                f.write(msgpack_dumps(scripts))

        from calibre.web.feeds.recipes.collection import \
                serialize_builtin_recipes, iterate_over_builtin_recipe_files

        files = [x[1] for x in iterate_over_builtin_recipe_files()]

        dest = self.j(self.RESOURCES, 'builtin_recipes.xml')
        if self.newer(dest, files):
            self.info('\tCreating builtin_recipes.xml')
            xml = serialize_builtin_recipes()
            with open(dest, 'wb') as f:
                f.write(xml)

        recipe_icon_dir = self.a(
            self.j(self.RESOURCES, '..', 'recipes', 'icons'))
        dest = os.path.splitext(dest)[0] + '.zip'
        files += glob.glob(self.j(recipe_icon_dir, '*.png'))
        if self.newer(dest, files):
            self.info('\tCreating builtin_recipes.zip')
            with zipfile.ZipFile(dest, 'w', zipfile.ZIP_STORED) as zf:
                for n in sorted(files, key=self.b):
                    with open(n, 'rb') as f:
                        zf.writestr(self.b(n), f.read())

        dest = self.j(self.RESOURCES, 'ebook-convert-complete.calibre_msgpack')
        files = []
        for x in os.walk(self.j(self.SRC, 'calibre')):
            for f in x[-1]:
                if f.endswith('.py'):
                    files.append(self.j(x[0], f))
        if self.newer(dest, files):
            self.info('\tCreating ' + self.b(dest))
            complete = {}
            from calibre.ebooks.conversion.plumber import supported_input_formats
            complete['input_fmts'] = set(supported_input_formats())
            from calibre.web.feeds.recipes.collection import get_builtin_recipe_titles
            complete['input_recipes'] = [
                t + '.recipe ' for t in get_builtin_recipe_titles()
            ]
            from calibre.customize.ui import available_output_formats
            complete['output'] = set(available_output_formats())
            from calibre.ebooks.conversion.cli import create_option_parser
            from calibre.utils.logging import Log
            log = Log()
            # log.outputs = []
            for inf in supported_input_formats():
                if inf in ('zip', 'rar', 'oebzip'):
                    continue
                for ouf in available_output_formats():
                    of = ouf if ouf == 'oeb' else 'dummy.' + ouf
                    p = create_option_parser(('ec', 'dummy1.' + inf, of, '-h'),
                                             log)[0]
                    complete[(inf, ouf)] = [
                        x + ' ' for x in get_opts_from_parser(p)
                    ]

            with open(dest, 'wb') as f:
                f.write(msgpack_dumps(complete))

        self.info('\tCreating template-functions.json')
        dest = self.j(self.RESOURCES, 'template-functions.json')
        function_dict = {}
        import inspect
        from calibre.utils.formatter_functions import formatter_functions
        for obj in formatter_functions().get_builtins().values():
            eval_func = inspect.getmembers(
                obj,
                lambda x: inspect.ismethod(x) and x.__name__ == 'evaluate')
            try:
                lines = [
                    l[4:] for l in inspect.getsourcelines(eval_func[0][1])[0]
                ]
            except:
                continue
            lines = ''.join(lines)
            function_dict[obj.name] = lines
        import json
        json.dump(function_dict, open(dest, 'wb'), indent=4)

        self.info('\tCreating editor-functions.json')
        dest = self.j(self.RESOURCES, 'editor-functions.json')
        function_dict = {}
        from calibre.gui2.tweak_book.function_replace import builtin_functions
        for func in builtin_functions():
            try:
                src = ''.join(inspect.getsourcelines(func)[0][1:])
            except Exception:
                continue
            src = src.replace('def ' + func.func_name, 'def replace')
            imports = [
                'from %s import %s' % (x.__module__, x.__name__)
                for x in func.imports
            ]
            if imports:
                src = '\n'.join(imports) + '\n\n' + src
            function_dict[func.name] = src
        json.dump(function_dict, open(dest, 'wb'), indent=4)
        self.info('\tCreating user-manual-translation-stats.json')
        d = {}
        for lc, stats in iteritems(
                json.load(
                    open(
                        self.j(self.d(self.SRC), 'manual', 'locale',
                               'completed.json')))):
            total = sum(itervalues(stats))
            d[lc] = stats['translated'] / float(total)
        json.dump(d,
                  open(
                      self.j(self.RESOURCES,
                             'user-manual-translation-stats.json'), 'wb'),
                  indent=4)
Exemple #35
0
def get_ln(fn):
    info = inspect.getsourcelines(fn)
    return info[1]
Exemple #36
0
    def test_controller_class_names(self):
        """This function checks that all controller class names end with
        either 'Handler', 'Page' or 'FileDownloader'.
        """
        # A mapping of returned handler types to expected name endings.
        handler_type_to_name_endings_dict = {
            feconf.HANDLER_TYPE_HTML: 'Page',
            feconf.HANDLER_TYPE_JSON: 'Handler',
            feconf.HANDLER_TYPE_DOWNLOADABLE: 'FileDownloader',
        }
        num_handlers_checked = 0
        for url in main.URLS:
            # URLS = MAPREDUCE_HANDLERS + other handlers. MAPREDUCE_HANDLERS
            # are tuples. So, below check is to pick only those which have
            # a RedirectRoute associated with it.
            if isinstance(url, main.routes.RedirectRoute):
                clazz = url.handler
                num_handlers_checked += 1
                all_base_classes = [base_class.__name__ for base_class in
                                    (inspect.getmro(clazz))]
                # Check that it is a subclass of 'BaseHandler'.
                if 'BaseHandler' in all_base_classes:
                    class_return_type = clazz.GET_HANDLER_ERROR_RETURN_TYPE
                    # Check that any class with a get handler has a
                    # GET_HANDLER_ERROR_RETURN_TYPE that's one of
                    # the allowed values.
                    if 'get' in clazz.__dict__.keys():
                        self.assertIn(
                            class_return_type,
                            handler_type_to_name_endings_dict)
                    class_name = clazz.__name__
                    file_name = inspect.getfile(clazz)
                    line_num = inspect.getsourcelines(clazz)[1]
                    allowed_class_ending = handler_type_to_name_endings_dict[
                        class_return_type]
                    # Check that the name of the class ends with
                    # the proper word if it has a get function.
                    if 'get' in clazz.__dict__.keys():
                        message = (
                            'Please ensure that the name of this class '
                            'ends with \'%s\'' % allowed_class_ending)
                        error_message = (
                            '%s --> Line %s: %s'
                            % (file_name, line_num, message))
                        self.assertTrue(
                            class_name.endswith(allowed_class_ending),
                            msg=error_message)

                    # Check that the name of the class ends with 'Handler'
                    # if it does not has a get function.
                    else:
                        message = (
                            'Please ensure that the name of this class '
                            'ends with \'Handler\'')
                        error_message = (
                            '%s --> Line %s: %s'
                            % (file_name, line_num, message))
                        self.assertTrue(class_name.endswith('Handler'),
                                        msg=error_message)

        self.assertGreater(num_handlers_checked, 150)
Exemple #37
0
def classSrcHyperlink(klass):
    'Return ReST-formatted line with hyperlinks to class headers (and implementation, if the corresponding .cpp file exists).'

    def findFirstLine(ff, pattern, regex=True):
        if regex: pat = re.compile(pattern)
        if not os.path.exists(ff): return -1
        numLines = [
            i for i, l in enumerate(open(ff).readlines())
            if (pat.match(l) if regex else (l == pattern))
        ]
        return (numLines[0] if numLines else -1)

    import woo.config, inspect, os, hashlib
    pysrc = inspect.getsourcefile(klass)
    if pysrc:  # python class
        lineNo = inspect.getsourcelines(klass)[1]
        pysrc1 = os.path.basename(pysrc)
        # locate the file in the source tree (as a quick hack, just use filename match)
        matches = []
        for root, dirnames, filenames in os.walk(woo.config.sourceRoot):
            relRoot = root[len(woo.config.sourceRoot) + 1:]
            if relRoot.startswith('build') or relRoot.startswith('debian'):
                continue  # garbage
            matches += [relRoot + '/' + f for f in filenames if f == pysrc1]
        if len(matches) > 1:
            #print 'WARN: multiple files named %s, using the first one: %s'%(pysrc1,str(matches))
            def fileHash(src):
                if sys.version_info[0] == 2:
                    return hashlib.md5(open(src).read()).hexdigest()
                else:
                    return hashlib.md5(
                        open(src).read().encode('utf-8')).hexdigest()

            md0 = fileHash(pysrc)
            matches = [
                m for m in matches
                if fileHash(woo.config.sourceRoot + '/' + m) == md0
            ]
            if len(matches) == 0:
                print(
                    'WARN: no file named %s with matching md5 digest found in source tree?'
                    % pysrc1)
                return None
            elif len(matches) > 1:
                print(
                    'WARN: multiple files named %s with the same md5 found in the source tree, using the one with shortest path.'
                    % pysrc1)
                matches.sort(key=len)
                match = matches[0]
            else:
                match = matches[0]
        elif len(matches) == 1:
            match = matches[0]
        else:
            print('WARN: no python source %s found.' % (pysrc1))
            return None
        return '[:woosrc:`%s <%s#L%s>`]' % (match, match, lineNo)

    if not klass._classTrait: return None
    f = klass._classTrait.file
    if f.startswith(woo.config.sourceRoot): commonRoot = woo.config.sourceRoot
    elif f.startswith(woo.config.buildRoot): commonRoot = woo.config.buildRoot
    elif not f.startswith('/'): commonRoot = ''
    else:
        print(
            'File where class is defined (%s) does not start with source root (%s) or build root (%s)'
            % (f, woo.config.sourceRoot, woo.config.buildRoot))
        return None
    # +1 removes underscore in woo/...
    f2 = f[len(commonRoot) + (1 if commonRoot else 0):]
    # if this header was copied into include/, get rid of that now
    m = re.match('include/woo/(.*)', f2)
    if m: f2 = m.group(1)
    if f2.endswith('.hpp'): hpp, cpp, lineIs = f2, f2[:-4] + '.cpp', 'hpp'
    elif f2.endswith('.cpp'): hpp, cpp, lineIs = f2[:-4] + '.hpp', f2, 'cpp'
    else: return None  # should not happen, anyway

    hppLine = findFirstLine(
        woo.config.sourceRoot + '/' + hpp,
        r'^(.*\s)?(struct|class)\s+%s\s*({|:).*$' % klass.__name__)
    cppLine = findFirstLine(woo.config.sourceRoot + '/' + cpp,
                            r'^(.*\s)?%s::.*$' % klass.__name__)
    ret = []
    if hppLine > 0: ret += [':woosrc:`%s <%s#L%d>`' % (hpp, hpp, hppLine + 1)]
    else:
        if f2.endswith('.hpp'):
            ret += [
                ':woosrc:`%s <%s#L%d>`' % (hpp, hpp, klass._classTrait.line)
            ]
        else:
            print('WARN: No header line found for %s in %s' %
                  (klass.__name__, hpp))
    if cppLine > 0: ret += [':woosrc:`%s <%s#L%d>`' % (cpp, cpp, cppLine + 1)]
    else: pass  # print 'No impl. line found for %s in %s'%(klass.__name__,cpp)
    #ret=[':woosrc:`header <%s#L%d>`'%(f2,klass._classTrait.line)]
    #if f2.endswith('.hpp'):
    #    cpp=woo.config.sourceRoot+'/'+f2[:-4]+'.cpp'
    #    # print 'Trying ',cpp
    #    if os.path.exists(cpp):
    #        # find first line in the cpp file which contains KlassName:: -- that's most likely where the implementation begins
    #        numLines=[i for i,l in enumerate(open(cpp).readlines()) if klass.__name__+'::' in l]
    #        if numLines: ret.append(':woosrc:`implementation <%s#L%d>`'%(f2[:-4]+'.cpp',numLines[0]+1))
    #        # return just the cpp file if the implementation is probably not there at all?
    #        # don't do it for now
    #        # else: ret.append(':woosrc:`implementation <%s#L>`'%(f2[:-4]+'.cpp'))
    if ret: return '[ ' + ' , '.join(ret) + ' ]'
    else: return None
Exemple #38
0
    def on_window_flip(self, window):
        '''Internal method to be called when the window have just displayed an
        image.
        When an image is showed, we decrement our framecount. If framecount is
        come to 0, we are taking the screenshot.

        The screenshot is done in a temporary place, and is compared to the
        original one -> test ok/ko.
        If no screenshot is available in the results directory, a new one will
        be created.
        '''
        from kivy.base import EventLoop
        from tempfile import mkstemp
        from os.path import join, exists
        from os import unlink, close
        from shutil import move, copy

        # don't save screenshot until we have enough frames.
        # log.debug('framecount %d' % self.framecount)
        # ! check if there is 'framecount', otherwise just
        # ! assume zero e.g. if handling runTouchApp manually
        self.framecount = getattr(self, 'framecount', 0) - 1
        if self.framecount > 0:
            return

        # don't create screenshots if not requested manually
        if not make_screenshots:
            EventLoop.stop()
            return

        reffn = None
        match = False
        try:
            # just get a temporary name
            fd, tmpfn = mkstemp(suffix='.png', prefix='kivyunit-')
            close(fd)
            unlink(tmpfn)

            # get a filename for the current unit test
            self.test_counter += 1
            test_uid = '%s-%d.png' % (
                '_'.join(self.id().split('.')[-2:]),
                self.test_counter)

            # capture the screen
            log.info('Capturing screenshot for %s' % test_uid)
            tmpfn = window.screenshot(tmpfn)
            log.info('Capture saved at %s' % tmpfn)

            # search the file to compare to
            reffn = join(self.results_dir, test_uid)
            log.info('Compare with %s' % reffn)

            # get sourcecode
            import inspect
            frame = inspect.getouterframes(inspect.currentframe())[6]
            sourcecodetab, line = inspect.getsourcelines(frame[0])
            line = frame[2] - line
            currentline = sourcecodetab[line]
            sourcecodetab[line] = '<span style="color: red;">%s</span>' % (
                currentline)
            sourcecode = ''.join(sourcecodetab)
            sourcecodetab[line] = '>>>>>>>>\n%s<<<<<<<<\n' % currentline
            sourcecodeask = ''.join(sourcecodetab)

            if not exists(reffn):
                log.info('No image reference, move %s as ref ?' % test_uid)
                if self.interactive_ask_ref(sourcecodeask, tmpfn, self.id()):
                    move(tmpfn, reffn)
                    tmpfn = reffn
                    log.info('Image used as reference')
                    match = True
                else:
                    log.info('Image discarded')
            else:
                from kivy.core.image import Image as CoreImage
                s1 = CoreImage(tmpfn, keep_data=True)
                sd1 = s1.image._data[0].data
                s2 = CoreImage(reffn, keep_data=True)
                sd2 = s2.image._data[0].data
                if sd1 != sd2:
                    log.critical(
                        '%s at render() #%d, images are different.' % (
                            self.id(), self.test_counter))
                    if self.interactive_ask_diff(sourcecodeask,
                                                 tmpfn, reffn, self.id()):
                        log.critical('user ask to use it as ref.')
                        move(tmpfn, reffn)
                        tmpfn = reffn
                        match = True
                    else:
                        self.test_failed = True
                else:
                    match = True

            # generate html
            from os.path import join, dirname, exists, basename
            from os import mkdir
            build_dir = join(dirname(__file__), 'build')
            if not exists(build_dir):
                mkdir(build_dir)
            copy(reffn, join(build_dir, 'ref_%s' % basename(reffn)))
            if tmpfn != reffn:
                copy(tmpfn, join(build_dir, 'test_%s' % basename(reffn)))
            with open(join(build_dir, 'index.html'), 'at') as fd:
                color = '#ffdddd' if not match else '#ffffff'
                fd.write('<div style="background-color: %s">' % color)
                fd.write('<h2>%s #%d</h2>' % (self.id(), self.test_counter))
                fd.write('<table><tr><th>Reference</th>'
                         '<th>Test</th>'
                         '<th>Comment</th>')
                fd.write('<tr><td><img src="ref_%s"/></td>' %
                         basename(reffn))
                if tmpfn != reffn:
                    fd.write('<td><img src="test_%s"/></td>' %
                             basename(reffn))
                else:
                    fd.write('<td>First time, no comparison.</td>')
                fd.write('<td><pre>%s</pre></td>' % sourcecode)
                fd.write('</table></div>')
        finally:
            try:
                if reffn != tmpfn:
                    unlink(tmpfn)
            except:
                pass
            EventLoop.stop()
Exemple #39
0
def linkcode_resolve(domain, info):
    """
    Determine the URL corresponding to Python object
    """
    if domain != 'py':
        return None

    modname = info['module']
    fullname = info['fullname']

    submod = sys.modules.get(modname)
    if submod is None:
        return None

    obj = submod
    for part in fullname.split('.'):
        try:
            obj = getattr(obj, part)
        except Exception:
            return None

    # strip decorators, which would resolve to the source of the decorator
    # possibly an upstream bug in getsourcefile, bpo-1764286
    try:
        unwrap = inspect.unwrap
    except AttributeError:
        pass
    else:
        obj = unwrap(obj)

    fn = None
    lineno = None

    # Make a poor effort at linking C extension types
    if isinstance(obj, type) and obj.__module__ == 'numpy':
        fn = _get_c_source_file(obj)

    if fn is None:
        try:
            fn = inspect.getsourcefile(obj)
        except Exception:
            fn = None
        if not fn:
            return None

        try:
            source, lineno = inspect.getsourcelines(obj)
        except Exception:
            lineno = None

        fn = relpath(fn, start=dirname(numpy.__file__))

    if lineno:
        linespec = "#L%d-L%d" % (lineno, lineno + len(source) - 1)
    else:
        linespec = ""

    if 'dev' in numpy.__version__:
        return "https://github.com/numpy/numpy/blob/master/numpy/%s%s" % (
            fn, linespec)
    else:
        return "https://github.com/numpy/numpy/blob/v%s/numpy/%s%s" % (
            numpy.__version__, fn, linespec)
Exemple #40
0
def getsourcelines(object):  # pylint: disable=redefined-builtin
  """TFDecorator-aware replacement for inspect.getsourcelines."""
  return _inspect.getsourcelines(tf_decorator.unwrap(object)[1])
Exemple #41
0
# Print the best Chromosomes from each Population
current_population_fits = []
current_population_chromosomes = []
for i in range(mp_ga.num_populations):
    current_population_fits.append(best_chromosomes[i].fitness)
    current_population_chromosomes.append(best_chromosomes[i].genes)

df_final = pd.DataFrame(
    {
        "name of test": str(name_of_test),
        "run time": run_time,
        "fit val": current_population_fits,
        "seed": seed,
        "eval start": start,
        "eval stop": stop,
        "complexity type": inspect.getsourcelines(fitness_function)[0][0],
        "k": k,
        "number of genes": num_genes,
        "number of populations": num_populations,
        "migration frequency": migration_frequency,
        "migration probability": migration_probability,
        "crossover probability": crossover_probability,
        "mutation probability": mutation_probability,
        "elitism ratio": elitism_ratio,
        "number of generations": generations,
    }
)

df_final.to_excel(("test_logs/" + name_of_test + "_results.xlsx"))
print("\nSaved parameters to " + name_of_test + "_results.xlsx")
Exemple #42
0
 def methodInfo(m):
     import inspect
     lines = inspect.getsourcelines(m)
     return "\nat %s:%s:\n %s" % (inspect.getsourcefile(m), lines[1],
                                  "\n".join(lines[0]))
    def make_wrapper(func):
        """
        make_wrapper function nested in iterate_jit decorator
        wraps specified func using apply_jit.
        """
        # Get the input arguments from the function
        in_args = inspect.getfullargspec(func).args
        # Get the numba.jit arguments
        jit_args = inspect.getfullargspec(jit).args + ['nopython']
        kwargs_for_jit = toolz.keyfilter(jit_args.__contains__, kwargs)

        # Any name that is a parameter
        # Boolean flag is given special treatment.
        # Identify those names here
        dd_key_list = list(Policy.default_data(metadata=True).keys())
        allowed_parameters = dd_key_list
        allowed_parameters += list(arg[1:] for arg in dd_key_list)
        additional_parameters = [
            arg for arg in in_args if arg in allowed_parameters
        ]
        additional_parameters += parameters
        # Remote duplicates
        all_parameters = list(set(additional_parameters))

        src = inspect.getsourcelines(func)[0]

        # Discover the return arguments by walking
        # the AST of the function
        grn = GetReturnNode()
        all_out_args = None
        for node in ast.walk(ast.parse(''.join(src))):
            all_out_args = grn.visit(node)
            if all_out_args:
                break
        if not all_out_args:
            raise ValueError("Can't find return statement in function!")

        # Now create the apply-style possibly-jitted function
        applied_jitted_f = make_apply_function(func,
                                               list(reversed(all_out_args)),
                                               in_args,
                                               parameters=all_parameters,
                                               do_jit=DO_JIT,
                                               **kwargs_for_jit)

        def wrapper(*args, **kwargs):
            """
            wrapper function nested in make_wrapper function nested
            in iterate_jit decorator.
            """
            in_arrays = []
            pm_or_pf = []
            for farg in all_out_args + in_args:
                if hasattr(args[0], farg):
                    in_arrays.append(getattr(args[0], farg))
                    pm_or_pf.append("pm")
                elif hasattr(args[1], farg):
                    in_arrays.append(getattr(args[1], farg))
                    pm_or_pf.append("pf")
            # Create the high level function
            high_level_func = create_toplevel_function_string(
                all_out_args, list(in_args), pm_or_pf)
            func_code = compile(high_level_func, "<string>", "exec")
            fakeglobals = {}
            eval(
                func_code,  # pylint: disable=eval-used
                {"applied_f": applied_jitted_f},
                fakeglobals)
            high_level_fn = fakeglobals['hl_func']
            ans = high_level_fn(*args, **kwargs)
            return ans

        return wrapper
Exemple #44
0
def linkcode_resolve(domain, info):  # NOQA: C901
    """
    Determine the URL corresponding to Python object

    Notes
    -----
    From https://github.com/numpy/numpy/blob/v1.15.1/doc/source/conf.py, 7c49cfa
    on Jul 31. License BSD-3. https://github.com/numpy/numpy/blob/v1.15.1/LICENSE.txt
    """
    if domain != "py":
        return None

    modname = info["module"]
    fullname = info["fullname"]

    submod = sys.modules.get(modname)
    if submod is None:
        return None

    obj = submod
    for part in fullname.split("."):
        try:
            obj = getattr(obj, part)
        except Exception:
            return None

    # strip decorators, which would resolve to the source of the decorator
    # possibly an upstream bug in getsourcefile, bpo-1764286
    try:
        unwrap = inspect.unwrap
    except AttributeError:
        pass
    else:
        obj = unwrap(obj)

    try:
        fn = inspect.getsourcefile(obj)
    except Exception:
        fn = None
    if not fn:
        return None

    try:
        source, lineno = inspect.getsourcelines(obj)
    except Exception:
        lineno = None

    if lineno:
        linespec = "#L%d-L%d" % (lineno, lineno + len(source) - 1)
    else:
        linespec = ""

    fn = relpath(fn, start=dirname(libtmux.__file__))

    if "dev" in about["__version__"]:
        return "{}/blob/master/{}/{}{}".format(
            about["__github__"],
            about["__package_name__"],
            fn,
            linespec,
        )
    else:
        return "{}/blob/v{}/{}/{}{}".format(
            about["__github__"],
            about["__version__"],
            about["__package_name__"],
            fn,
            linespec,
        )
Exemple #45
0
def function_source(function):
    return ''.join(inspect.getsourcelines(function)[0])
Exemple #46
0
    track_max_fitness.append(max(current_population_fits))
    track_final_chromosome.append(best_chrom)

df_final = pd.DataFrame({
    "name of test": [str(name_of_test)] * len(param_change),
    "run time":
    track_run_time,
    "fit vals":
    track_final_fit_value,
    "max fitness":
    track_max_fitness,
    "seed": [seed] * len(param_change),
    "eval start": [start] * len(param_change),
    "eval stop": [stop] * len(param_change),
    "complexity type":
    inspect.getsourcelines(fitness_function)[0][0] * len(param_change),
    "k": [k] * len(param_change),
    "number of genes": [num_genes] * len(param_change),
    "number of populations": [num_populations] * len(param_change),
    "migration frequency": [migration_frequency] * len(param_change),
    "migration probability": [migration_probability] * len(param_change),
    "crossover probability": [crossover_probability] * len(param_change),
    "mutation probability": [mutation_probability] * len(param_change),
    "elitism ratio": [elitism_ratio] * len(param_change),
    "number of generations": [generations] * len(param_change),
})

df_final.to_excel(("test_logs/" + name_of_test + "_results.xlsx"))
print("\nSaved parameters to " + name_of_test + "_results.xlsx")

# save chromosomes separately
Exemple #47
0
    def __call__(self, request):
        """
        Handler that mimics what CubicWebPublisher.main_handle_request and
        CubicWebPublisher.core_handle do
        """

        req = request.cw_request
        vreg = request.registry['cubicweb.registry']

        try:
            content = None
            try:
                with cw_to_pyramid(request):
                    ctrlid, rset = self.appli.url_resolver.process(
                        req, req.path)

                    try:
                        controller = vreg['controllers'].select(
                            ctrlid, req, appli=self.appli)
                        log.info(
                            "REQUEST [%s] '%s' selected controller %s at %s:%s",
                            ctrlid, req.path, controller,
                            inspect.getsourcefile(controller.__class__),
                            inspect.getsourcelines(controller.__class__)[1])
                        emit_to_debug_channel("vreg", {
                            "vreg": vreg,
                        })
                        emit_to_debug_channel(
                            "controller", {
                                "kind": ctrlid,
                                "request": req,
                                "path": req.path,
                                "controller": controller,
                                "config": self.appli.repo.config,
                            })
                    except cubicweb.NoSelectableObject:
                        log.warn("WARNING '%s' unauthorized request", req.path)
                        raise httpexceptions.HTTPUnauthorized(
                            req._('not authorized'))

                    req.update_search_state()
                    content = controller.publish(rset=rset)

                    # XXX this auto-commit should be handled by the cw_request
                    # cleanup or the pyramid transaction manager.
                    # It is kept here to have the ValidationError handling bw
                    # compatible
                    if req.cnx:
                        txuuid = req.cnx.commit()
                        # commited = True
                        if txuuid is not None:
                            req.data['last_undoable_transaction'] = txuuid
            except cubicweb.web.ValidationError as ex:
                # XXX The validation_error_handler implementation is light, we
                # should redo it better in cw_to_pyramid, so it can be properly
                # handled when raised from a cubicweb view.
                # BUT the real handling of validation errors should be done
                # earlier in the controllers, not here. In the end, the
                # ValidationError should never by handled here.
                content = self.appli.validation_error_handler(req, ex)
            except cubicweb.web.RemoteCallFailed:
                # XXX The default pyramid error handler (or one that we provide
                # for this exception) should be enough
                # content = self.appli.ajax_error_handler(req, ex)
                raise

            if content is not None:
                request.response.body = content

        except LogOut as ex:
            # The actual 'logging out' logic should be in separated function
            # that is accessible by the pyramid views
            headers = security.forget(request)
            raise HTTPSeeOther(ex.url, headers=headers)
        except cubicweb.AuthenticationError:
            # Will occur upon access to req.cnx which is a
            # cubicweb.dbapi._NeedAuthAccessMock.
            if not content:
                content = vreg['views'].main_template(req, 'login')
                request.response.status_code = 403
                request.response.body = content
        except cubicweb.web.NotFound as ex:
            view = vreg['views'].select('404', req)
            content = vreg['views'].main_template(req, view=view)
            request.response.status_code = ex.status
            request.response.body = content
        finally:
            # XXX CubicWebPyramidRequest.headers_out should
            # access directly the pyramid response headers.
            request.response.headers.clear()
            for k, v in req.headers_out.getAllRawHeaders():
                for item in v:
                    request.response.headers.add(k, item)

        return request.response
Exemple #48
0
 def get_dependencies(self):
     return inspect.getsourcelines(self.imports_loc)[0]
def to_ast(func, line=None):
    lines = inspect.getsourcelines(func)[0]
    if line:
        return ast.parse(lines[line-func.func_code.co_firstlineno])
    else:
        return ast.parse(''.join(lines))
Exemple #50
0
def hooks():
    import functools
    import inspect
    list_op = [
        '_%s_%s' % (h, m) for h in ['before', 'after']
        for m in ['insert', 'update', 'delete']
    ]
    tables = []
    with_build_it = False
    for db_str in sorted(databases):
        db = databases[db_str]
        for t in db.tables:
            method_hooks = []
            for op in list_op:
                functions = []
                for f in getattr(db[t], op):
                    if hasattr(f, '__call__'):
                        try:
                            if isinstance(f, (functools.partial)):
                                f = f.func
                            filename = inspect.getsourcefile(f)
                            details = {
                                'funcname':
                                f.__name__,
                                'filename':
                                filename[len(request.folder):]
                                if request.folder in filename else None,
                                'lineno':
                                inspect.getsourcelines(f)[1]
                            }
                            if details[
                                    'filename']:  # Built in functions as delete_uploaded_files are not editable
                                details['url'] = URL(
                                    a='admin',
                                    c='default',
                                    f='edit',
                                    args=[
                                        request['application'],
                                        details['filename']
                                    ],
                                    vars={'lineno': details['lineno']})
                            if details['filename'] or with_build_it:
                                functions.append(details)
                        # compiled app and windows build don't support code inspection
                        except:
                            pass
                if len(functions):
                    method_hooks.append({'name': op, 'functions': functions})
            if len(method_hooks):
                tables.append({
                    'name': "%s.%s" % (db_str, t),
                    'slug': IS_SLUG()("%s.%s" % (db_str, t))[0],
                    'method_hooks': method_hooks
                })
    # Render
    ul_main = UL(_class='nav nav-list')
    for t in tables:
        ul_main.append(A(t['name'], _onclick="collapse('a_%s')" % t['slug']))
        ul_t = UL(_class='nav nav-list',
                  _id="a_%s" % t['slug'],
                  _style='display:none')
        for op in t['method_hooks']:
            ul_t.append(LI(op['name']))
            ul_t.append(
                UL([
                    LI(
                        A(f['funcname'],
                          _class="editor_filelink",
                          _href=f['url'] if 'url' in f else None,
                          **{'_data-lineno': f['lineno'] - 1}))
                    for f in op['functions']
                ]))
        ul_main.append(ul_t)
    return ul_main
Exemple #51
0
def check_spelling_words(doc: Docstring) -> list:
    """
    Check spelling of chosen words in doc.

    Parameters
    ----------
    doc : numpydoc.validate.Docstring
        Docstring handler.

    Returns
    -------
    list
        List of tuples with Modin error code and its description.

    Notes
    -----
    Any special words enclosed in apostrophes(") are treated as python string
    constants and are not checked for spelling.
    """
    if not doc.raw_doc:
        return []
    components = set(
        ["Modin", "pandas", "NumPy", "Ray", "Dask"]
        + ["PyArrow", "OmniSci", "XGBoost", "Plasma"]
    )
    check_words = "|".join(x.lower() for x in components)

    # comments work only with re.VERBOSE
    pattern = r"""
    (?:                     # non-capturing group
        [^-\\\w\/]          # any symbol except: '-', '\', '/' and any from [a-zA-Z0-9_]
        | ^                 # or line start
    )
    ({check_words})         # words to check, example - "modin|pandas|numpy"
    (?:                     # non-capturing group
        [^-"\.\/\w\\]       # any symbol except: '-', '"', '.', '\', '/' and any from [a-zA-Z0-9_]
        | \.\s              # or '.' and any whitespace
        | \.$               # or '.' and line end
        | $                 # or line end
    )
    """.format(
        check_words=check_words
    )
    results = [
        set(re.findall(pattern, line, re.I | re.VERBOSE)) - components
        for line in doc.raw_doc.splitlines()
    ]

    docstring_start_line = None
    for idx, line in enumerate(inspect.getsourcelines(doc.code_obj)[0]):
        if '"""' in line or "'''" in line:
            docstring_start_line = doc.source_file_def_line + idx
            break

    errors = []
    for line_idx, words_in_line in enumerate(results):
        for word in words_in_line:
            reference = [x for x in components if x.lower() == word.lower()][0]
            errors.append(
                (
                    "MD02",
                    MODIN_ERROR_CODES["MD02"].format(
                        line=docstring_start_line + line_idx,
                        word=word,
                        reference=reference,
                    ),
                )
            )
    return errors
Exemple #52
0
 def aux(self, *args, **kwargs):
     class_ = type(self)
     print (inspect.getsourcelines(class_) 
            == inspect.getsourcelines(type(self)))
     f(self, *args, **kwargs)
Exemple #53
0
    def tracer(self, frame, event, arg):
        #print Cstr("1:FRAME: " + str(frame)).tocyan()
        #print Cstr("2:EVENT: " + event).toblue()
        #print Cstr("3:ARG:   " + str(arg)).tored()

        #
        # Reference: https://pymotw.com/2/sys/tracing.html
        #
        # NOTE: c_call, c_return, and c_exception are not supported
        #       to be traced
        #
        if event in ["line", "return", "call", "exception"]:
            seconds = int(time.time() - self.tracer_start_time)
            lineno = frame.f_lineno
            funcname = frame.f_code.co_name
            filename = frame.f_code.co_filename

            #
            # For /usr/lib/python*/*.py, always print
            # its absolute path
            #
            if not filename.startswith("/usr/lib"):
                n = self.tracer_rpath_depth
                filename = '/'.join(filename.split('/')[n:])

            flag = self._debug_query(funcname, filename)
            if not flag:
                return None

            try:
                thisframe = inspect.getsourcelines(frame)
                lineno_base = thisframe[1]
                lineno_offset = lineno - lineno_base
                lineco = thisframe[0][lineno_offset].rstrip()
            except:
                errmsg = "-- Oops, source code not found --"
                lineco = Cstr(errmsg).tomagenta()

            s = self.debug_utag
            s += Cstr('[').togray()
            s += Cstr(funcname).tomagenta() + '()'
            s += Cstr('@').togray()
            s += Cstr(filename).toblue()
            s += Cstr(':').togray()
            s += Cstr("%d" % lineno).togray()
            s += Cstr('|').togray()
            s += Cstr("%d" % seconds).tomagenta()
            s += Cstr(']').togray()
            if event == "line":
                s += '+ ' + lineco

            elif event == "return":
                s0 = s

                rtag = "<RETURN>"
                s += "++ %s ++ %s" % \
                    (Cstr(rtag).tocyan(),
                     Cstr(str(arg)).tocyan())

                if self.tracer_verbose >= 3:
                    rtag = "<GLOBALS>"
                    gvars = str(frame.f_globals)
                    s += '\n' + s0
                    s += "++ %s ++ %s" % \
                        (Cstr(rtag).tocyan(),
                         Cstr(gvars).tocyan())

                if self.tracer_verbose >= 2:
                    rtag = "<LOCALS>"
                    try:
                        arg_info = \
                            inspect.getargvalues(frame)
                        lvars = str(arg_info.locals)
                    except:
                        lvars = ""
                    s += '\n' + s0
                    s += "++ %s ++ %s" % \
                        (Cstr(rtag).tocyan(),
                         Cstr(lvars).tocyan())

                if self.tracer_verbose >= 1:
                    rtag = "</CALLER>"
                    sprev = self._get_caller(frame)
                    s += '\n' + s0
                    s += "++ %s ++ %s" % \
                        (Cstr(rtag).tocyan(),
                         Cstr(sprev).tocyan())

            elif event == "call":
                s0 = s

                if self.tracer_verbose >= 1:
                    rtag = "<CALLER> "
                    sprev = self._get_caller(frame)
                    s += "++ %s ++ %s" % \
                        (Cstr(rtag).tocyan(),
                         Cstr(sprev).tocyan())
                    s += '\n' + s0

                try:
                    arg_info = inspect.getargvalues(frame)
                    funcargs = str(arg_info.locals)
                except:
                    funcargs = ""
                fd4 = 'def ' + funcname + funcargs + ':'
                s += '++ ' + Cstr(fd4).tocyan()

            elif event == "exception":
                s += '++ ' + Cstr(str(arg)).tored()

            else:
                pass

            if self.tracer_sleep_nsecs != 0:
                time.sleep(self.tracer_sleep_nsecs)

            sys.stderr.write("%s\n" % s)

        return self.tracer
Exemple #54
0
from inspectiontest import Child, Parent
import inspect

child = Child()
test_func = child.parent_test

print('Is Method: %s' % inspect.ismethod(test_func))
print('Is Function: %s' % inspect.isfunction(test_func))
print(test_func.__self__)
lines = inspect.getsourcelines(test_func)
source_code = "".join(lines[0])
print(source_code)
Exemple #55
0
def get_setup_cache_key(func):
    if func is None:
        return None
    return '{0}:{1}'.format(inspect.getsourcefile(func),
                            inspect.getsourcelines(func)[1])
Exemple #56
0
 def __init__(self, fn):
     code, firstline = inspect.getsourcelines(fn)
     self.filepath = inspect.getfile(fn).replace(Config.get_project_path(),
                                                 '')
     self.start_line = firstline
     self.end_line = firstline + len(code) - 1
Exemple #57
0
def get_function_source(ft) -> str:
    "Returns link to `ft` in source code."
    lineno = inspect.getsourcelines(ft)[1]
    return get_source_link(inspect.getmodule(ft), lineno)
Exemple #58
0
# Reading data
# ===========
# In this part we'll get the crisis years from a published IMF data set.
#
# First let's get the standard country codes coresponding to these countries using dracula.

# <codecell>

import inspect
from dracula.extractor import Extractor
import dracula
extractor = Extractor()
country_codes = {}
countries = extractor.grab_metadata("countries")
print(inspect.getsourcelines(dracula.wb.parser.parse_multiple_countries_alone))
for country in countries:
    #print(dir(country))
    country_codes[country.name] = country.code
print(country_codes)

# <markdowncell>

# Manual fixing

# <codecell>

country_codes["Serbia, Republic of"] = 'SRB'
country_codes['Brunei'] = 'BRN'
country_codes[u"Lao People’s Dem. Rep."] = 'LAO'
country_codes['Venezuela'] = 'VEN'
Exemple #59
0
# RESULTS OF THIS TEST DEPEND ON THE CPYTHON
# VERSION AND PYTHON ENVIRONMENT USED
# TO RUN not_impl_mods_gen.py

"""

output += gen_methods()
output += f"""
cpymods = {gen_modules()!r}
libdir = {os.path.abspath("../Lib/").encode('utf8')!r}

"""

# Copy the source code of functions we will reuse in the generated script
for fn in [attr_is_not_inherited, extra_info, dir_of_mod_or_error]:
    output += "".join(inspect.getsourcelines(fn)[0]) + "\n\n"

# Prevent missing variable linter errors from compare()
expected_methods = {}
cpymods = {}
libdir = ""


# This function holds the source code that will be run under RustPython
def compare():
    import inspect
    import io
    import os
    import re
    import sys
    import warnings
Exemple #60
0
df_final = pd.DataFrame({
    "name of test":
    str(name_of_test),
    "run time":
    run_time,
    "fit val":
    current_population_fits,
    "seed":
    seed,
    "eval start":
    start,
    "eval stop":
    stop,
    "complexity type":
    inspect.getsourcelines(fitness_function)[0][0],
    "k":
    k,
    "number of genes":
    num_genes,
    "number of populations":
    num_populations,
    "migration frequency":
    migration_frequency,
    "migration probability":
    migration_probability,
    "crossover probability":
    crossover_probability,
    "mutation probability":
    mutation_probability,
    "elitism ratio":