desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Get the changes this refactoring makes
If `getter` is not `None`, that will be the name of the
getter, otherwise ``get_${field_name}`` will be used. The
same is true for `setter` and if it is None set_${field_name} is
used.
`resources` can be a list of `rope.base.resource.File`\s that
the refactoring should be applied on; if `None` all python
files in the project are searched.'
| def get_changes(self, getter=None, setter=None, resources=None, task_handle=taskhandle.NullTaskHandle()):
| if (resources is None):
resources = self.project.get_python_files()
changes = ChangeSet(('Encapsulate field <%s>' % self.name))
job_set = task_handle.create_jobset('Collecting Changes', len(resources))
if (getter is None):
getter = ('get_' + self.name)
if (setter is None):
setter = ('set_' + self.name)
renamer = GetterSetterRenameInModule(self.project, self.name, self.pyname, getter, setter)
for file in resources:
job_set.started_job(file.path)
if (file == self.resource):
result = self._change_holding_module(changes, renamer, getter, setter)
changes.add_change(ChangeContents(self.resource, result))
else:
result = renamer.get_changed_module(file)
if (result is not None):
changes.add_change(ChangeContents(file, result))
job_set.finished_job()
return changes
|
'Get the name of the field to be encapsulated'
| def get_field_name(self):
| return self.name
|
'Return the changes needed for this refactoring
Parameters:
- `dest_attr`: the name of the destination attribute
- `new_name`: the name of the new method; if `None` uses
the old name
- `resources` can be a list of `rope.base.resources.File`\s to
apply this refactoring on. If `None`, the restructuring
will be applied to all python files.'
| def get_changes(self, dest_attr, new_name=None, resources=None, task_handle=taskhandle.NullTaskHandle()):
| changes = ChangeSet(('Moving method <%s>' % self.method_name))
if (resources is None):
resources = self.project.get_python_files()
if (new_name is None):
new_name = self.get_method_name()
(resource1, start1, end1, new_content1) = self._get_changes_made_by_old_class(dest_attr, new_name)
collector1 = codeanalyze.ChangeCollector(resource1.read())
collector1.add_change(start1, end1, new_content1)
(resource2, start2, end2, new_content2) = self._get_changes_made_by_new_class(dest_attr, new_name)
if (resource1 == resource2):
collector1.add_change(start2, end2, new_content2)
else:
collector2 = codeanalyze.ChangeCollector(resource2.read())
collector2.add_change(start2, end2, new_content2)
result = collector2.get_changed()
import_tools = importutils.ImportTools(self.project)
new_imports = self._get_used_imports(import_tools)
if new_imports:
goal_pymodule = libutils.get_string_module(self.project, result, resource2)
result = _add_imports_to_module(import_tools, goal_pymodule, new_imports)
if (resource2 in resources):
changes.add_change(ChangeContents(resource2, result))
if (resource1 in resources):
changes.add_change(ChangeContents(resource1, collector1.get_changed()))
return changes
|
'Constructor
if replacement is `None` the region is not changed. Otherwise
it is replaced with `replacement`.'
| def __init__(self, occurrence_finder, resource, handle=None, skip_start=0, skip_end=0, replacement=''):
| self.occurrence_finder = occurrence_finder
self.resource = resource
self.skip_start = skip_start
self.skip_end = skip_end
self.replacement = replacement
self.handle = handle
if (self.handle is None):
self.handle = ModuleSkipRenamerHandle()
|
'Get the changes this refactoring makes
If `remove` is `False` the definition will not be removed. If
`only_current` is `True`, the the current occurrence will be
inlined, only.'
| def get_changes(self, remove=True, only_current=False, resources=None, task_handle=taskhandle.NullTaskHandle()):
| changes = ChangeSet(('Inline method <%s>' % self.name))
if (resources is None):
resources = self.project.get_python_files()
if only_current:
resources = [self.original]
if remove:
resources.append(self.resource)
job_set = task_handle.create_jobset('Collecting Changes', len(resources))
for file in resources:
job_set.started_job(file.path)
if (file == self.resource):
changes.add_change(self._defining_file_changes(changes, remove=remove, only_current=only_current))
else:
aim = None
if (only_current and (self.original == file)):
aim = self.offset
handle = _InlineFunctionCallsForModuleHandle(self.project, file, self.others_generator, aim)
result = move.ModuleSkipRenamer(self.occurrence_finder, file, handle).get_changed_module()
if (result is not None):
result = _add_imports(self.project, result, file, self.imports)
if remove:
result = _remove_from(self.project, self.pyname, result, file)
changes.add_change(ChangeContents(file, result))
job_set.finished_job()
return changes
|
'Get the changes needed by this refactoring
See `rope.refactor.change_signature.ChangeSignature.get_changes()`
for arguments.'
| def get_changes(self, **kwds):
| return self.signature.get_changes(self.changers, **kwds)
|
'Inlines occurrences
If `aim` is not `None` only the occurrences that intersect
`aim` offset will be inlined.'
| def __init__(self, project, resource, definition_generator, aim_offset=None):
| self.project = project
self.generator = definition_generator
self.resource = resource
self.aim = aim_offset
|
'Set the value of `key` preference to `value`.'
| def set(self, key, value):
| if (key in self.callbacks):
self.callbacks[key](value)
else:
self.prefs[key] = value
|
'Add an entry to a list preference
Add `value` to the list of entries for the `key` preference.'
| def add(self, key, value):
| if (not (key in self.prefs)):
self.prefs[key] = []
self.prefs[key].append(value)
|
'Get the value of the key preference'
| def get(self, key, default=None):
| return self.prefs.get(key, default)
|
'Add `key` preference with `callback` function
Whenever `key` is set the callback is called with the
given `value` as parameter.'
| def add_callback(self, key, callback):
| self.callbacks[key] = callback
|
'Return the names defined or imported in this scope'
| def get_names(self):
| return self.pyobject.get_attributes()
|
'Return the names defined in this scope'
| def get_defined_names(self):
| return self.pyobject._get_structural_attributes()
|
'Return name `PyName` defined in this scope'
| def get_name(self, name):
| if (name not in self.get_names()):
raise exceptions.NameNotFoundError(('name %s not found' % name))
return self.get_names()[name]
|
'The same as ``get_name(key)``'
| def __getitem__(self, key):
| return self.get_name(key)
|
'The same as ``key in self.get_names()``'
| def __contains__(self, key):
| return (key in self.get_names())
|
'Return the subscopes of this scope
The returned scopes should be sorted by the order they appear.'
| @utils.saveit
def get_scopes(self):
| return self._create_scopes()
|
'Return the visible names of this scope
Return the names defined in this scope that are visible from
scopes containing this scope. This method returns the same
dictionary returned by `get_names()` except for `ClassScope`
which returns an empty dict.'
| def get_propagated_names(self):
| return self.get_names()
|
'Execute the process'
| def run(self):
| env = dict(os.environ)
file_path = self.file.real_path
path_folders = (self.pycore.project.get_source_folders() + self.pycore.project.get_python_path_folders())
env['PYTHONPATH'] = os.pathsep.join((folder.real_path for folder in path_folders))
runmod_path = self.pycore.project.find_module('rope.base.oi.runmod').real_path
self.receiver = None
self._init_data_receiving()
send_info = '-'
if self.receiver:
send_info = self.receiver.get_send_info()
args = [sys.executable, runmod_path, send_info, self.pycore.project.address, self.file.real_path]
if (self.analyze_data is None):
del args[1:4]
if (self.args is not None):
args.extend(self.args)
self.process = subprocess.Popen(executable=sys.executable, args=args, env=env, cwd=os.path.split(file_path)[0], stdin=self.stdin, stdout=self.stdout, stderr=self.stdout, close_fds=(os.name != 'nt'))
|
'Wait for the process to finish'
| def wait_process(self):
| self.process.wait()
if self.analyze_data:
self.receiving_thread.join()
|
'Stop the process'
| def kill_process(self):
| if (self.process.poll() is not None):
return
try:
if hasattr(self.process, 'terminate'):
self.process.terminate()
elif (os.name != 'nt'):
os.kill(self.process.pid, 9)
else:
import ctypes
handle = int(self.process._handle)
ctypes.windll.kernel32.TerminateProcess(handle, (-1))
except OSError:
pass
|
'Notify this observer when execution finishes'
| def add_finishing_observer(self, observer):
| self.observers.append(observer)
|
':type pyobject: rope.base.pyobjects.PyObject
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyobject, *args, **kwargs):
| type_factory = self._get_type_factory(pyobject)
if type_factory:
parametrized_type = type_factory(*args, **kwargs)
if parametrized_type:
return parametrized_type
return pyobject
|
':type delegates: list[rope.base.oi.type_hinting.providers.interfaces.IParamProvider]'
| def __init__(self, *delegates):
| self._delegates = delegates
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:type param_name: str
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc, param_name):
| for delegate in self._delegates:
result = delegate(pyfunc, param_name)
if result:
return result
|
':type delegates: list[rope.base.oi.type_hinting.providers.interfaces.IReturnProvider]'
| def __init__(self, *delegates):
| self._delegates = delegates
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc):
| for delegate in self._delegates:
result = delegate(pyfunc)
if result:
return result
|
':type delegates: list[rope.base.oi.type_hinting.providers.interfaces.IAssignmentProvider]'
| def __init__(self, *delegates):
| self._delegates = delegates
|
':type pyname: rope.base.pynamesdef.AssignedName
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyname):
| for delegate in self._delegates:
result = delegate(pyname)
if result:
return result
|
':type docstring_parser: rope.base.oi.type_hinting.providers.docstrings.IParamParser
:type resolver: rope.base.oi.type_hinting.resolvers.interfaces.IResolver'
| def __init__(self, docstring_parser, resolver):
| self._parse_docstring = docstring_parser
self._resolve = resolver
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:type param_name: str
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc, param_name):
| type_strs = self._parse_docstring(pyfunc.get_doc(), param_name)
if type_strs:
return self._resolve(type_strs[0], pyfunc)
|
':type docstring_parser: rope.base.oi.type_hinting.providers.docstrings.IReturnParser
:type resolver: rope.base.oi.type_hinting.resolvers.interfaces.IResolver'
| def __init__(self, docstring_parser, resolver):
| self._parse_docstring = docstring_parser
self._resolve = resolver
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc):
| type_strs = self._parse_docstring(pyfunc.get_doc())
if type_strs:
return self._resolve(type_strs[0], pyfunc)
|
':type docstring_parser: rope.base.oi.type_hinting.providers.docstrings.IParamParser
:type resolver: rope.base.oi.type_hinting.resolvers.interfaces.IResolver'
| def __init__(self, docstring_parser, resolver):
| self._parse_docstring = docstring_parser
self._resolve = resolver
|
':type pyname: rope.base.pynamesdef.AssignedName
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyname):
| try:
(pyclass, attr_name) = utils.get_class_with_attr_name(pyname)
except TypeError:
return
else:
type_strs = self._parse_docstring(pyclass.get_doc(), attr_name)
if type_strs:
return self._resolve(type_strs[0], pyclass)
|
'Search `docstring` for type(-s) of `param_name`.
>>> DocstringParamParser()(\':type param: int\', \'param\')
[\'int\']
>>> DocstringParamParser()(\'@type param: int\', \'param\')
[\'int\']
>>> DocstringParamParser()(\':type param: :class:`threading.Thread`\', \'param\')
[\'threading.Thread\']
>>> bool(DocstringParamParser()(\'no document\', \'param\'))
False
>>> DocstringParamParser()(\':param int param: some description\', \'param\')
[\'int\']'
| def __call__(self, docstring, param_name):
| if (not docstring):
return []
patterns = [re.compile((p % re.escape(param_name))) for p in self.DOCSTRING_PARAM_PATTERNS]
for pattern in patterns:
match = pattern.search(docstring)
if match:
return [self._strip_rst_role(match.group(1))]
return []
|
'Strip off the part looks like a ReST role in `type_str`.
>>> RSTRoleStrip()(\':class:`ClassName`\') # strip off :class:
\'ClassName\'
>>> RSTRoleStrip()(\':py:obj:`module.Object`\') # works with domain
\'module.Object\'
>>> RSTRoleStrip()(\'ClassName\') # do nothing when not ReST role
\'ClassName\'
See also:
http://sphinx-doc.org/domains.html#cross-referencing-python-objects'
| def __call__(self, type_str):
| match = self.RST_ROLE_PATTERN.match(type_str)
if match:
return match.group(1)
else:
return type_str
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:type param_name: str
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc, param_name):
| raise NotImplementedError
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc):
| raise NotImplementedError
|
':type pyname: rope.base.pynamesdef.AssignedName
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyname):
| raise NotImplementedError
|
':type resolver: rope.base.oi.type_hinting.resolvers.interfaces.IResolver'
| def __init__(self, resolver):
| self._resolve = resolver
|
':type pyname: rope.base.pynamesdef.AssignedName
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyname):
| from rope.base.oi.soi import _get_lineno_for_node
lineno = _get_lineno_for_node(pyname.assignments[0].ast_node)
holding_scope = pyname.module.get_scope().get_inner_scope_for_line(lineno)
line = holding_scope._get_global_scope()._scope_finder.lines.get_line(lineno)
if ('#' in line):
type_strs = self._search_type_in_type_comment(line.split('#', 1)[1])
if type_strs:
return self._resolve(type_strs[0], holding_scope.pyobject)
|
'For more info see:
https://www.python.org/dev/peps/pep-0484/#type-comments
>>> AssignmentProvider()._search_type_in_type_comment(\'type: int\')
[\'int\']'
| def _search_type_in_type_comment(self, code):
| for p in self.PEP0484_TYPE_COMMENT_PATTERNS:
match = p.search(code)
if match:
return [match.group(1)]
|
':type delegate: rope.base.oi.type_hinting.providers.interfaces.IParamProvider'
| def __init__(self, delegate):
| self._delegate = delegate
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:type param_name: str
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc, param_name):
| superfunc = pyfunc
while superfunc:
result = self._delegate(superfunc, param_name)
if result:
return result
superfunc = utils.get_super_func(superfunc)
|
':type delegate: rope.base.oi.type_hinting.providers.interfaces.IReturnProvider'
| def __init__(self, delegate):
| self._delegate = delegate
|
':type pyfunc: rope.base.pyobjectsdef.PyFunction
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyfunc):
| superfunc = pyfunc
while superfunc:
result = self._delegate(superfunc)
if result:
return result
superfunc = utils.get_super_func(superfunc)
|
':type delegate: rope.base.oi.type_hinting.providers.interfaces.IAssignmentProvider'
| def __init__(self, delegate):
| self._delegate = delegate
|
':type pyname: rope.base.pynamesdef.AssignedName
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, pyname):
| super_pyname = pyname
while super_pyname:
result = self._delegate(super_pyname)
if result:
return result
super_pyname = utils.get_super_assignment(super_pyname)
|
'Search `docstring` (in numpydoc format) for type(-s) of `param_name`.'
| def __call__(self, docstring, param_name):
| params = NumpyDocString(docstring)._parsed_data['Parameters']
for (p_name, p_type, p_descr) in params:
if (p_name == param_name):
m = re.match('([^,]+(,[^,]+)*?)(,[ ]*optional)?$', p_type)
if m:
p_type = m.group(1)
if p_type.startswith('{'):
types = set((type(x).__name__ for x in literal_eval(p_type)))
return list(types)
else:
return [p_type]
return []
|
':rtype: rope.base.oi.type_hinting.resolvers.interfaces.IResolver'
| @utils.saveit
def make_resolver(self):
| resolvers = [types.Resolver()]
return composite_resolvers.Resolver(*resolvers)
|
':type project: rope.base.project.Project
:rtype: rope.base.oi.type_hinting.interfaces.ITypeHintingFactory'
| def __call__(self, project):
| factory_location = project.get_prefs().get('type_hinting_factory', 'rope.base.oi.type_hinting.factory.default_type_hinting_factory')
return self._get_factory(factory_location)
|
':type factory_location: str
:rtype: rope.base.oi.type_hinting.interfaces.ITypeHintingFactory'
| @utils.cached(10)
def _get_factory(self, factory_location):
| return utils.resolve(factory_location)
|
':rtype: rope.base.oi.type_hinting.providers.interfaces.IParamProvider'
| def make_param_provider(self):
| raise NotImplementedError
|
':rtype: rope.base.oi.type_hinting.providers.interfaces.IReturnProvider'
| def make_return_provider(self):
| raise NotImplementedError
|
':rtype: rope.base.oi.type_hinting.providers.interfaces.IAssignmentProvider'
| def make_assignment_provider(self):
| raise NotImplementedError
|
':rtype: rope.base.oi.type_hinting.resolvers.interfaces.IResolver'
| def make_resolver(self):
| raise NotImplementedError
|
':type program: str
:rtype: rope.base.oi.type_hinting.evaluate.SymbolBase'
| @base_utils.cached(500)
def __call__(self, program):
| return self._make_parser().parse(program)
|
'Evaluates the program string or AST
:type program: str or rope.base.oi.type_hinting.evaluate.SymbolBase
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, program, pyobject):
| ast = (self.compile(program) if isinstance(program, pycompat.string_types) else program)
return ast.evaluate(pyobject)
|
':type delegates: list[rope.base.oi.type_hinting.resolvers.interfaces.IResolver]'
| def __init__(self, *delegates):
| self._delegates = delegates
|
':param hint: For example "List[int]" or "(Foo, Bar) -> Baz" or simple "Foo"
:type hint: str
:type pyobject: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, hint, pyobject):
| for delegate in self._delegates:
result = delegate(hint, pyobject)
if result:
return result
|
':param hint: For example "List[int]" or "(Foo, Bar) -> Baz" or simple "Foo"
:type hint: str
:type pyobject: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, hint, pyobject):
| raise NotImplementedError
|
':param hint: For example "List[int]" or "(Foo, Bar) -> Baz" or simple "Foo"
:type hint: str
:type pyobject: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject
:rtype: rope.base.pyobjects.PyDefinedObject | rope.base.pyobjects.PyObject or None'
| def __call__(self, hint, pyobject):
| try:
return evaluate.evaluate(hint, pyobject)
except Exception:
pass
|
'Transform a `PyObject` to textual form'
| def transform(self, pyobject):
| if (pyobject is None):
return ('none',)
object_type = type(pyobject)
try:
method = getattr(self, (object_type.__name__ + '_to_textual'))
return method(pyobject)
except AttributeError:
return ('unknown',)
|
'Transform an object from textual form to `PyObject`'
| def transform(self, textual):
| if (textual is None):
return None
type = textual[0]
try:
method = getattr(self, (type + '_to_pyobject'))
return method(textual)
except AttributeError:
return None
|
'`argumens` is an instance of `Arguments`'
| def __init__(self, pyname, arguments, scope):
| self.pyname = pyname
self.args = arguments
|
'The `level` is `None` for simple assignments and is
a list of numbers for tuple assignments for example in::
a, (b, c) = x
The levels for for `a` is ``[0]``, for `b` is ``[1, 0]`` and for
`c` is ``[1, 1]``.'
| def __init__(self, ast_node, levels=None, evaluation='', assign_type=False):
| self.ast_node = ast_node
if (levels is None):
self.levels = []
else:
self.levels = levels
self.evaluation = evaluation
self.assign_type = assign_type
|
'Forget the `PyObject` this `PyName` holds'
| def invalidate(self):
| self.pyobject.set(None)
|
'Get a resource in a project.
`resource_name` is the path of a resource in a project. It is
the path of a resource relative to project root. Project root
folder address is an empty string. If the resource does not
exist a `exceptions.ResourceNotFound` exception would be
raised. Use `get_file()` and `get_folder()` when you need to
get nonexistent `Resource`\s.'
| def get_resource(self, resource_name):
| path = self._get_resource_path(resource_name)
if (not os.path.exists(path)):
raise exceptions.ResourceNotFoundError(('Resource <%s> does not exist' % resource_name))
elif os.path.isfile(path):
return File(self, resource_name)
elif os.path.isdir(path):
return Folder(self, resource_name)
else:
raise exceptions.ResourceNotFoundError(('Unknown resource ' + resource_name))
|
'Returns a `PyObject` if the module was found.'
| def get_module(self, name, folder=None):
| pymod = self.pycore.builtin_module(name)
if (pymod is not None):
return pymod
module = self.find_module(name, folder)
if (module is None):
raise ModuleNotFoundError(('Module %s not found' % name))
return self.pycore.resource_to_pyobject(module)
|
'Returns project source folders'
| def get_source_folders(self):
| if (self.root is None):
return []
result = list(self._custom_source_folders)
result.extend(self.pycore._find_source_folders(self.root))
return result
|
'Validate files and folders contained in this folder
It validates all of the files and folders contained in this
folder if some observers are interested in them.'
| def validate(self, folder):
| for observer in list(self.observers):
observer.validate(folder)
|
'Register a `ResourceObserver`
See `FilteredResourceObserver`.'
| def add_observer(self, observer):
| self.observers.append(observer)
|
'Remove a registered `ResourceObserver`'
| def remove_observer(self, observer):
| if (observer in self.observers):
self.observers.remove(observer)
|
'Apply the changes in a `ChangeSet`
Most of the time you call this function for committing the
changes for a refactoring.'
| def do(self, changes, task_handle=taskhandle.NullTaskHandle()):
| self.history.do(changes, task_handle=task_handle)
|
'Get the file with `path` (it may not exist)'
| def get_file(self, path):
| return File(self, path)
|
'Get the folder with `path` (it may not exist)'
| def get_folder(self, path):
| return Folder(self, path)
|
'Returns a resource corresponding to the given module
returns None if it can not be found'
| def find_module(self, modname, folder=None):
| for src in self.get_source_folders():
module = _find_module_in_folder(src, modname)
if (module is not None):
return module
for src in self.get_python_path_folders():
module = _find_module_in_folder(src, modname)
if (module is not None):
return module
if (folder is not None):
module = _find_module_in_folder(folder, modname)
if (module is not None):
return module
return None
|
'A rope project
:parameters:
- `projectroot`: The address of the root folder of the project
- `fscommands`: Implements the file system operations used
by rope; have a look at `rope.base.fscommands`
- `ropefolder`: The name of the folder in which rope stores
project configurations and data. Pass `None` for not using
such a folder at all.
- `prefs`: Specify project preferences. These values
overwrite config file preferences.'
| def __init__(self, projectroot, fscommands=None, ropefolder='.ropeproject', **prefs):
| if (projectroot != '/'):
projectroot = _realpath(projectroot).rstrip('/\\')
self._address = projectroot
self._ropefolder_name = ropefolder
if (not os.path.exists(self._address)):
os.mkdir(self._address)
elif (not os.path.isdir(self._address)):
raise exceptions.RopeError('Project root exists and is not a directory')
if (fscommands is None):
fscommands = rope.base.fscommands.create_fscommands(self._address)
super(Project, self).__init__(fscommands)
self.ignored = _ResourceMatcher()
self.file_list = _FileListCacher(self)
self.prefs.add_callback('ignored_resources', self.ignored.set_patterns)
if (ropefolder is not None):
self.prefs['ignored_resources'] = [ropefolder]
self._init_prefs(prefs)
self._init_source_folders()
|
'Returns all python files available in the project'
| def get_python_files(self):
| return [resource for resource in self.get_files() if self.pycore.is_python_file(resource)]
|
'Closes project open resources'
| def sync(self):
| self.close()
|
'Closes project open resources'
| def close(self):
| self.data_files.write()
|
'Set the `key` preference to `value`'
| def set(self, key, value):
| self.prefs.set(key, value)
|
'Get function type
It returns one of \'function\', \'method\', \'staticmethod\' or
\'classmethod\' strs.'
| def get_kind(self):
| scope = self.parent.get_scope()
if isinstance(self.parent, PyClass):
for decorator in self.decorators:
pyname = rope.base.evaluate.eval_node(scope, decorator)
if (pyname == rope.base.builtins.builtins['staticmethod']):
return 'staticmethod'
if (pyname == rope.base.builtins.builtins['classmethod']):
return 'classmethod'
return 'method'
return 'function'
|
'A `SourceLinesAdapter`'
| @property
@utils.saveit
def lines(self):
| return rope.base.codeanalyze.SourceLinesAdapter(self.source_code)
|
'A `LogicalLinesFinder`'
| @property
@utils.saveit
def logical_lines(self):
| return rope.base.codeanalyze.CachingLogicalLineFinder(self.lines)
|
'The same as ``get_attribute(key)``'
| def __getitem__(self, key):
| return self.get_attribute(key)
|
'The same as ``key in self.get_attributes()``'
| def __contains__(self, key):
| return (key in self.get_attributes())
|
'Check the equality of two `PyObject`\s
Currently it is assumed that instances (the direct instances
of `PyObject`, not the instances of its subclasses) are equal
if their types are equal. For every other object like
defineds or builtins rope assumes objects are reference
objects and their identities should match.'
| def __eq__(self, obj):
| if (self.__class__ != obj.__class__):
return False
if (type(self) == PyObject):
if (self is not self.type):
return (self.type == obj.type)
else:
return (self.type is obj.type)
return (self is obj)
|
'See docs for `__eq__()` method'
| def __hash__(self):
| if ((type(self) == PyObject) and (self != self.type)):
return (hash(self.type) + 1)
else:
return super(PyObject, self).__hash__()
|
'The same as ``iter(self.get_attributes())``'
| def __iter__(self):
| return iter(self.get_attributes())
|
'Should initialize _starts and _ends attributes'
| def _init_logicals(self):
| size = (self.lines.length() + 1)
self._starts = ([None] * size)
self._ends = ([None] * size)
for (start, end) in self._generate(self.lines):
self._starts[start] = True
self._ends[end] = True
|
'It is called when the resource changes'
| def resource_changed(self, resource):
| if (self.changed is not None):
self.changed(resource)
|
'It is called when a resource is moved'
| def resource_moved(self, resource, new_resource):
| if (self.moved is not None):
self.moved(resource, new_resource)
|
'Is called when a new resource is created'
| def resource_created(self, resource):
| if (self.created is not None):
self.created(resource)
|
'Is called when a new resource is removed'
| def resource_removed(self, resource):
| if (self.removed is not None):
self.removed(resource)
|
'Validate the existence of this resource and its children.
This function is called when rope need to update its resource
cache about the files that might have been changed or removed
by other processes.'
| def validate(self, resource):
| if (self._validate is not None):
self._validate(resource)
|
'Add a resource to the list of interesting resources'
| def add_resource(self, resource):
| if resource.exists():
self.resources[resource] = self.timekeeper.get_indicator(resource)
else:
self.resources[resource] = None
|
'Add a resource to the list of interesting resources'
| def remove_resource(self, resource):
| if (resource in self.resources):
del self.resources[resource]
|
'Removes all registered resources'
| def clear_resources(self):
| self.resources.clear()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.