mirror of
https://gitflic.ru/project/openide/openide.git
synced 2025-12-16 22:51:17 +07:00
9335c066f5
Now it more follows original python grammar. GitOrigin-RevId: f2b45554d16ff87d946950591f0e92fedcfdfaf0
1228 lines
72 KiB
Properties
1228 lines
72 KiB
Properties
### Quick fixes ###
|
|
QFIX.optimize.imports=Optimize imports
|
|
|
|
QFIX.add.import.add.import=Add "''{0}''"
|
|
|
|
QFIX.statement.effect.introduce.variable=Introduce variable
|
|
|
|
#PyImplementMethodsQuickFix
|
|
QFIX.NAME.implement.methods=Implement abstract methods
|
|
|
|
QFIX.NAME.change.signature=Change signature
|
|
QFIX.change.signature.of=Change signature of {0}
|
|
|
|
QFIX.NAME.rename.element=Rename element
|
|
|
|
QFIX.ignore.unresolved.reference=Ignore unresolved reference
|
|
QFIX.ignore.unresolved.reference.0=Ignore unresolved reference ''{0}''
|
|
QFIX.mark.all.unresolved.attributes.of.0.as.ignored=Mark all unresolved attributes of ''{0}'' as ignored
|
|
QFIX.fill.paragraph=Fill paragraph
|
|
QFIX.remove.trailing.blank.lines=Remove trailing blank lines
|
|
QFIX.generating.skeletons.for.binary.module=Generating skeletons for binary module
|
|
QFIX.generate.binary.stubs=Generate binary stubs
|
|
QFIX.reformat.file=Reformat file
|
|
QFIX.bold.html.text=<b>{0}</b>
|
|
|
|
# Namespace packages
|
|
QFIX.mark.as.namespace.package=Mark directory ''{0}'' as namespace package
|
|
QFIX.change.to.same.directory.import=Change to same directory import
|
|
|
|
# Intentions: INTN
|
|
|
|
# Conflict checker
|
|
CONFLICT.name.obscured.by.local.definitions=Name ''{0}'' obscured by local definitions
|
|
CONFLICT.name.obscured.cannot.convert=Name ''{0}'' obscured. Cannot convert.
|
|
CONFLICT.occurrence.pl=occurrences
|
|
|
|
##########################################################################################################################
|
|
# Unwrap
|
|
##########################################################################################################################
|
|
unwrap.if=Unwrap if...
|
|
unwrap.while=Unwrap while...
|
|
unwrap.for=Unwrap for...
|
|
unwrap.with=Unwrap with...
|
|
unwrap.try=Unwrap try...
|
|
unwrap.else=Unwrap else...
|
|
unwrap.elif=Unwrap elif...
|
|
remove.else=Remove else...
|
|
remove.elif=Remove elif...
|
|
|
|
INSP.GROUP.python=Python
|
|
|
|
# Refactoring
|
|
refactoring.will.not.be.accessible=Member, you are trying to move depends on ''{0}'' which will not be accessible after this refactoring
|
|
refactoring.error.file.exists=File "{0}" already exists
|
|
refactoring.error.directory.exists=Directory "{0}" already exists
|
|
|
|
# introduce
|
|
refactoring.introduce.name.error=Incorrect name
|
|
refactoring.introduce.selection.error=Cannot perform refactoring using selected element(s)
|
|
|
|
# introduce variable
|
|
refactoring.introduce.variable.dialog.title=Extract Variable
|
|
refactoring.introduce.variable.scope.error=Name clashes with existing variable or parameter
|
|
|
|
# introduce constant
|
|
refactoring.introduce.constant.dialog.title=Extract Constant
|
|
refactoring.introduce.constant.scope.error=Name is already declared in scope
|
|
|
|
# introduce parameter
|
|
refactoring.extract.parameter.dialog.title=Extract Parameter
|
|
refactoring.introduce.parameter.dialog.title=Introduce Parameter
|
|
|
|
# pull up
|
|
refactoring.pull.up.dialog.title=Pull members up to
|
|
refactoring.pull.up.dialog.move.members.to.class=Move members to class
|
|
refactoring.pull.up.dialog.members.to.be.moved=Following members would be moved
|
|
refactoring.pull.up.error.cannot.perform.refactoring.not.inside.class=Cannot perform pull member up: not inside the class
|
|
refactoring.pull.up.error.cannot.perform.refactoring.no.base.classes=Class {0} has no super classes or none of them could be used for refactoring
|
|
|
|
# inline
|
|
refactoring.inline.local.multiassignment=Definition is in multi-assign
|
|
|
|
# inline function
|
|
refactoring.inline.function.title=Inline Function
|
|
refactoring.inline.this.only=Inline this invocation only and keep the declaration
|
|
refactoring.inline.function=Inline function {0}
|
|
refactoring.inline.method=Inline method {0}
|
|
refactoring.inline.all.keep.declaration=Inline all invocations and keep the declaration
|
|
refactoring.inline.all.remove.declaration=Inline all invocations and remove the declaration
|
|
refactoring.inline.all.border.title=Inline
|
|
refactoring.inline.label.function=Function {0}
|
|
refactoring.inline.label.method=Method {0}
|
|
refactoring.name.label.text={0} has {1} occurrence{2, choice, 0#|1#s}
|
|
refactoring.inline.function.command.name=Inlining {0}
|
|
refactoring.inline.function.function.to.inline=Function to inline
|
|
refactoring.inline.function.invocations.to.be.inlined=Invocations to be inlined in {0} files
|
|
refactoring.inline.function.is.decorator=Function {0} is used as a decorator and cannot be inlined. Function definition will not be removed
|
|
refactoring.inline.function.is.reference=Function {0} is used as a reference and cannot be inlined. Function definition will not be removed
|
|
refactoring.inline.function.uses.unpacking=Function {0} uses argument unpacking and cannot be inlined. Function definition will not be removed
|
|
refactoring.inline.function.generator=Cannot inline generators
|
|
refactoring.inline.function.async=Cannot inline async functions
|
|
refactoring.inline.function.constructor=Cannot inline constructor calls
|
|
refactoring.inline.function.builtin=Cannot inline builtin functions
|
|
refactoring.inline.function.special.method=Cannot inline special methods
|
|
refactoring.inline.function.skeleton.only=Cannot inline function from binary module
|
|
refactoring.inline.function.decorator=Cannot inline functions with decorators
|
|
refactoring.inline.function.self.referrent=Cannot inline functions that reference themselves
|
|
refactoring.inline.function.star=Cannot inline functions with * arguments
|
|
refactoring.inline.function.overrides.method=Cannot inline methods that override other methods
|
|
refactoring.inline.function.is.overridden=Cannot inline overridden methods
|
|
refactoring.inline.function.global=Cannot inline functions with global variables
|
|
refactoring.inline.function.nonlocal=Cannot inline functions with nonlocals variables
|
|
refactoring.inline.function.nested=Cannot inline functions with another function declaration
|
|
refactoring.inline.function.interrupts.flow=Cannot inline functions that interrupt control flow
|
|
|
|
# extract method
|
|
refactoring.extract.method=Extract method
|
|
refactoring.extract.method.error.bad.selection=Cannot perform extract method using selected element(s)
|
|
refactoring.extract.method.error.name.clash=Method name clashes with already existing name
|
|
refactoring.extract.method.error.returns=Cannot extract method with return instructions inside code fragment
|
|
refactoring.extract.method.error.local.variable.modifications=Cannot perform refactoring from expression with local variable modifications inside code fragment
|
|
refactoring.extract.method.error.local.variable.modifications.and.returns=Cannot perform refactoring from expression with local variables modifications and return instructions inside code fragment
|
|
refactoring.extract.method.error.empty.fragment=Cannot perform refactoring from empty code fragment
|
|
|
|
refactoring.extract.method.error.class.level=Cannot perform refactoring at class level
|
|
|
|
# extract superclass
|
|
refactoring.extract.super.target.path.outside.roots=Target directory is outside the project. Must be within content roots
|
|
refactoring.extract.super.target.class.already.exists=Class ''{0}'' already exists in this module
|
|
refactoring.extract.super.name.0.must.be.ident=Name ''{0}'' is invalid. Must be a valid Python identifier
|
|
refactoring.extract.super.class.no.members.allowed=None of members could be extracted
|
|
|
|
# move
|
|
refactoring.move.choose.destination.file.title=Choose Destination File
|
|
refactoring.move.error.destination.file.contains.class=Destination file already contains class named ''{0}''
|
|
refactoring.move.error.destination.file.contains.function=Destination file already contains function named ''{0}''
|
|
refactoring.move.error.destination.file.contains.global.variable=Destination file already contains global variable named ''{0}''
|
|
refactoring.move.error.cannot.use.module.name=Cannot use module name ''{0}'' in imports
|
|
|
|
|
|
# move module members (top-level)
|
|
refactoring.move.module.members=Move module members
|
|
refactoring.move.module.members.dialog.title=Move Module Members
|
|
refactoring.move.module.members.dialog.table.title=Bulk &move
|
|
refactoring.move.module.members.dialog.description.class=Move class {0}
|
|
refactoring.move.module.members.dialog.description.function=Move function {0}
|
|
refactoring.move.module.members.dialog.description.variable=Move global variable {0}
|
|
refactoring.move.module.members.dialog.description.selection=Move selected elements
|
|
refactoring.move.module.members.error.cannot.place.elements.into.nonpython.file=Cannot place elements into a non-Python file
|
|
refactoring.move.module.members.error.selection=Cannot perform refactoring using selected element(s)
|
|
|
|
# Make function top-level
|
|
refactoring.make.method.top.level.dialog.title=Make Method Top-Level
|
|
refactoring.make.method.top.level.dialog.description=Move method {0} to top-level
|
|
|
|
refactoring.make.local.function.top.level.dialog.title=Make Local Function Top-Level
|
|
refactoring.make.local.function.top.level.dialog.description=Move local function {0} to top-level
|
|
|
|
refactoring.make.function.top.level.error.nonlocal.writes=Cannot move function with nonlocal writes
|
|
refactoring.make.function.top.level.error.self.reads=Cannot move function that contains usages of "self" parameter from outer scope
|
|
refactoring.make.function.top.level.error.outer.scope.reads=Cannon move method that references names from the outer scope
|
|
refactoring.make.function.top.level.error.private.attributes=Cannot move method that references private instance attributes
|
|
refactoring.make.function.top.level.error.attribute.writes=Cannot move method that writes to instance attributes
|
|
refactoring.make.function.top.level.error.method.calls=Cannot move method that calls other methods of the same class
|
|
refactoring.make.function.top.level.error.special.usage.of.self=Cannot move method that contains special usages of "self" parameter
|
|
|
|
|
|
|
|
#change signature
|
|
refactoring.change.signature.usage.view.declarations.header=Functions to be refactored
|
|
refactoring.change.signature.dialog.validation.name.defined=Name is already defined in scope
|
|
refactoring.change.signature.dialog.validation.function.name=Incorrect function name
|
|
refactoring.change.signature.dialog.validation.parameter.name=Incorrect parameter name
|
|
refactoring.change.signature.dialog.validation.multiple.star=Multiple * arguments are not allowed
|
|
refactoring.change.signature.dialog.validation.multiple.double.star=Multiple ** arguments are not allowed
|
|
refactoring.change.signature.dialog.validation.default.missing=Default value is missing
|
|
refactoring.change.signature.dialog.validation.parameter.missing=Parameter name is missing
|
|
refactoring.change.signature.dialog.default.value.checkbox=Use default value in signature:
|
|
refactoring.change.signature.dialog.name.label=Name:
|
|
refactoring.change.signature.find.usages.of.base.class=Method {0} of class {1}\noverrides method of class {2}.\nDo you want to refactor the base method?
|
|
refactoring.change.signature.error.wrong.caret.position.method.name=The caret should be positioned at the name of the method to be refactored
|
|
refactoring.change.signature.error.lambda.call=Caret is positioned on lambda call
|
|
refactoring.change.signature.error.tuple.parameters=Function contains tuple parameters
|
|
refactoring.change.signature.error.not.under.source.root=Function is not under the source root
|
|
refactoring.change.signature.suggested.callSite.value=Value of a call site
|
|
refactoring.change.signature.suggested.callSite.value.optional=Optional value of a call site
|
|
|
|
refactoring.convert.package.to.module.error.not.empty.package=Package "{0}" is not empty
|
|
|
|
refactoring.occurrences.count={0} ({1} occurrences)
|
|
refactoring.introduce.field.setup.method=setUp() method
|
|
refactoring.introduce.field.cannot.be.used.in.static.methods=Introduce Field refactoring cannot be used in static methods
|
|
refactoring.introduce.field.not.in.class=Cannot introduce field: not in class
|
|
refactoring.rename.containing.file.with.the.following.name.to=Rename containing file with the following name to:
|
|
refactoring.rename.containing.file.title=Rename Containing File
|
|
refactoring.rename.containing.file=Rename containing file
|
|
refactoring.rename.containing.file.entity.name=Containing File
|
|
refactoring.rename.parameter.in.hierarchy.to=Rename parameter in hierarchy to:
|
|
refactoring.rename.parameter.entity.name=Parameter
|
|
refactoring.rename.parameters.title=Rename Parameters
|
|
refactoring.rename.parameters.in.hierarchy=Rename parameters in hierarchy
|
|
refactoring.rename=Rename
|
|
refactoring.rename.not.valid.identifier=The name ''{0}'' is not a valid Python identifier. Cannot update import statement in ''{1}''
|
|
refactoring.rename.inheritor.classes.with.the.following.names.to=Rename inheritor classes with the following names to:
|
|
refactoring.rename.inheritors.title=Rename Inheritors
|
|
refactoring.rename.inheritors=Rename inheritors
|
|
refactoring.rename.inheritor.class.entity.name=Inheritor Class
|
|
|
|
### Annotators ###
|
|
ANN.default.except.must.be.last=default 'except:' must be last
|
|
ANN.no.exception.to.reraise=No exception to reraise
|
|
|
|
ANN.name.used.both.as.global.and.param=Name ''{0}'' used both as a parameter and as a global
|
|
|
|
ANN.assignment.to.keyword=Assignment to keyword
|
|
ANN.cannot.assign.to.debug=Cannot assign to __debug__
|
|
ANN.unparenthesized.assignment.expression.statement=Unparenthesized assignment expressions are prohibited at the top level of an expression statement
|
|
ANN.unparenthesized.assignment.expression.value=Unparenthesized assignment expressions are prohibited at the top level of the right hand side of an assignment statement
|
|
ANN.assignment.expressions.within.a.comprehension.cannot.be.used.in.a.class.body=Assignment expressions within a comprehension cannot be used in a class body
|
|
ANN.ignore.errors.like.this=Ignore errors like this
|
|
ANN.function.cannot.be.async=function \"{0}\" cannot be async
|
|
ANN.python.does.not.support.yield.from.inside.async.functions=Python does not support 'yield from' inside async functions
|
|
ANN.yield.outside.of.function='yield' outside of function
|
|
ANN.non.empty.return.inside.asynchronous.generator=non-empty 'return' inside asynchronous generator
|
|
ANN.return.outside.of.function='return' outside of function
|
|
ANN.can.t.use.starred.expression.here=Can't use starred expression here
|
|
ANN.illegal.target.for.variable.annotation=Illegal target for variable annotation
|
|
ANN.variable.annotation.cannot.be.combined.with.tuple.unpacking=Variable annotation cannot be combined with tuple unpacking
|
|
ANN.variable.annotation.cannot.be.used.in.assignment.with.multiple.targets=Variable annotation cannot be used in assignment with multiple targets
|
|
ANN.generator.expression.must.be.parenthesized.if.not.sole.argument=Generator expression must be parenthesized if not sole argument
|
|
|
|
ANN.fstrings.expression.fragment.inside.fstring.nested.too.deeply=Expression fragment inside f-string is nested too deeply
|
|
ANN.fstrings.missing.conversion.character=Conversion character is expected: should be one of 's', 'r', 'a'
|
|
ANN.fstrings.illegal.conversion.character=Illegal conversion character ''{0}'': should be one of ''s'', ''r'', ''a''
|
|
ANN.fstrings.expression.fragments.cannot.include.backslashes=Expression fragments inside f-strings cannot include backslashes
|
|
ANN.fstrings.single.right.brace.not.allowed.inside.fstrings=Single '}' is not allowed inside f-strings
|
|
ANN.fstrings.expression.fragments.cannot.include.line.comments=Expression fragments inside f-strings cannot include line comments
|
|
|
|
python.run.select.script=Select Script
|
|
python.run.configuration=Python run configuration
|
|
python.run.python=Python
|
|
|
|
testing.form.inspect.only.subclasses.of.unittest.testcase=Inspect only subclasses of unittest.TestCase
|
|
python.testing.target.not.provided=Target not provided
|
|
python.testing.provide.qualified.name=Provide a qualified name of function, class or a module"
|
|
python.testing.pattern.can.only.be.used=Pattern can only be used to match files in folder. Can't use pattern for file.
|
|
python.testing.cant.resolve=Can't resolve {0}. Try to remove configuration and generate it again
|
|
python.testing.cant.find.where.declared=Can't find file where {0} declared. Make sure it is in project root
|
|
python.testing.cant.get.importable.name=Can't get importable name for {0}. Is it a python file in project?
|
|
|
|
runcfg.tests.cant_rerun=Can't rerun tests since test IDs can't be resolved. Try to delete run configuration, and create new one using right click.
|
|
runcfg.tests.empty_suite=Empty suite
|
|
|
|
### doctest run conf
|
|
runcfg.doctest.display_name=Doctests
|
|
runcfg.python_tests.config.additionalArguments=Additional Arguments
|
|
runcfg.python_tests.config.target=Target
|
|
runcfg.python_tests.config.targetType=Target Type
|
|
|
|
### nosetests run conf
|
|
runcfg.nosetests.display_name=Nosetests
|
|
runcfg.nosetests.config.regexPattern=Regex Pattern
|
|
|
|
### pytest run conf
|
|
runcfg.pytest.display_name=pytest
|
|
runcfg.pytest.suggested.name=pytest in {0}
|
|
|
|
# deprecated start
|
|
runcfg.pytest.target=&Target:
|
|
runcfg.pytest.parameters=&Options:
|
|
runcfg.pytest.keywords=&Keywords:
|
|
# deprecated end
|
|
|
|
runcfg.pytest.config.keywords=Keywords
|
|
runcfg.pytest.config.parameters=Parameters
|
|
|
|
|
|
### trial run conf
|
|
runcfg.trial.display_name=Twisted Trial
|
|
|
|
### test run configuration
|
|
runcfg.test.display_name=Python tests
|
|
runcfg.test.description=Python frameworks supported by PyCharm
|
|
runcfg.test.suggest.name.in.path={0} in {1}
|
|
runcfg.test.suggest.name.in.python={0} for {1}
|
|
|
|
|
|
### tox
|
|
runcfg.tox.runner=tox runner
|
|
runcfg.tox=tox
|
|
|
|
### unittest run configuration
|
|
runcfg.unittest.config.pattern=Pattern
|
|
|
|
runcfg.unittest.display_name=Unittests
|
|
runcfg.unittest.no_script_name=Please specify script name
|
|
runcfg.unittest.no_module_name=Please specify module qualified name
|
|
runcfg.unittest.no_class_name=Please specify class name
|
|
runcfg.unittest.no_method_name=Please specify method name
|
|
runcfg.unittest.no_folder_name=Please specify folder with tests
|
|
runcfg.unittest.dlg.test_script_label=Script:
|
|
runcfg.unittest.dlg.class_label=Class:
|
|
runcfg.unittest.dlg.method_label=Method:
|
|
runcfg.unittest.dlg.function_label=Function:
|
|
runcfg.unittest.dlg.folder_path=Folder:
|
|
runcfg.unittest.dlg.test_type_title=Test:
|
|
runcfg.unittest.dlg.all_in_folder_title=All in folder
|
|
runcfg.unittest.dlg.all_in_script_title=Script
|
|
runcfg.unittest.dlg.test_class_title=Class
|
|
runcfg.unittest.dlg.test_method_title=Method
|
|
runcfg.unittest.no_valid_sdk=Please select a valid Python interpreter
|
|
runcfg.unittest.no_module_sdk=Please select a module with a valid Python SDK
|
|
runcfg.unittest.no_sdk=Please specify a Python SDK
|
|
runcfg.unittest.dlg.select.folder.path=Select folder path:
|
|
runcfg.unittest.dlg.select.script.path=Select script path:
|
|
runcfg.unittest.dlg.interpreter_options_title=Interpreter options:
|
|
runcfg.unittest.suggest.name.in.class={0} in {1}
|
|
runcfg.unittest.suggest.name.in.script={0} in {1}
|
|
runcfg.unittest.suggest.name.in.folder={0} in {1}
|
|
runcfg.labels.script_parameters=&Parameters:
|
|
runcfg.labels.environment_variables=&Environment variables:
|
|
runcfg.labels.interpreter=&Use specified interpreter:
|
|
runcfg.labels.use.sdk.of.module=Use SDK of module:
|
|
runcfg.labels.interpreter_options=Interpreter &options:
|
|
runcfg.labels.working_directory=&Working directory:
|
|
runcfg.captions.script_parameters_dialog=Enter script parameters
|
|
runcfg.captions.interpreter_options_dialog=Enter interpreter options
|
|
runcfg.labels.python.interpreter=&Python interpreter:
|
|
runcfg.labels.add.content.roots.to.pythonpath=Add content roots to PYTHONPATH
|
|
runcfg.labels.add.source.roots.to.pythonpath=Add source roots to PYTHONPATH
|
|
runcfg.labels.path.mappings=Path mappings
|
|
runcfg.labels.project=Pro&ject:
|
|
runcfg.labels.script.path=Script path
|
|
runcfg.labels.module.name=Module name
|
|
runcfg.labels.custom.name=Custom
|
|
runcfg.labels.execution=Execution
|
|
python.sdk.error.invalid.interpreter.name=Invalid Python interpreter name ''{0}''!
|
|
sdk.select.path=Select Python Interpreter
|
|
runcfg.unittest.dlg.pattern=Pattern:
|
|
|
|
runcfg.testing.no.test.framework=No {0} runner found in selected interpreter
|
|
runcfg.testing.specify.target.folder.or.script=Please specify target folder or script
|
|
|
|
runcfg.error.message.failed.to.find.free.socket.port=Failed to find free socket port
|
|
runcfg.error.message.cannot.find.python.interpreter=Cannot find Python interpreter for this run configuration
|
|
|
|
# Consoles messages
|
|
python.console=Python Console
|
|
python.console.history.root=Python Consoles
|
|
python.console.run.anything.provider=Runs Python Console
|
|
python.console.not.supported=Python console for {0} interpreter is not supported
|
|
|
|
#Buildout
|
|
buildout=Buildout
|
|
buildout.unresolved.part.inspection=Buildout config unresolved part inspection
|
|
buildout.unresolved.part.inspection.msg=Unresolved part reference
|
|
buildout.configurable.enable.buildout.support.checkbox.text=&Enable buildout support
|
|
runcfg.unittest.dlg.test_function_title=Function
|
|
run.configuration.remote.debug.name=Python Remote Debug
|
|
run.configuration.remote.debug.visible.name=Python Debug Server
|
|
run.configuration.type.description=Starts server for remote debug
|
|
run.configuration.show.command.line.action.name=Show Debug Console
|
|
|
|
unable.to.stop=Currently running process can't be stopped. Kill it manually first.
|
|
|
|
#Debug
|
|
|
|
debug.popup.title.step.into.function=Step Into Function
|
|
|
|
debug.notification.group=Python debugger
|
|
debug.notification.title.connection.failed=Connection to Python debugger failed
|
|
|
|
remote.debug.server.hint=Launch this debug configuration to start the Debug Server.
|
|
remote.debug.server.hint1.5=Update your script:
|
|
remote.debug.server.hint2=1. Add pydevd-pycharm.egg from the PyCharm installation to the Python path or execute:
|
|
remote.debug.server.hint3=pip install pydevd-pycharm
|
|
remote.debug.server.hint4=2. Add the following command to connect to the Debug Server:
|
|
remote.debug.port=Port:
|
|
remote.debug.local.host=IDE host name:
|
|
remote.debug.redirect.output=Redirect output to console
|
|
remote.debug.suspend.on.connect=Suspend after connect
|
|
|
|
# Debug VFS
|
|
|
|
python.debug.remote.name=PyRemoteDebug
|
|
python.debug.remote.description=Remote debug
|
|
|
|
python.sdk.getting.remote.interpreter.version=Getting Remote Interpreter Version
|
|
python.sdk.directory.macro.description=The directory containing the Python interpreter selected for the project
|
|
python.sdk.scanning.installed.packages=Scanning installed packages...
|
|
python.sdk.updater.notifications.group.title=Python SDK Updater
|
|
python.sdk.updating.skeletons=Updating skeletons...
|
|
python.sdk.updating.python.paths=Updating Python Paths
|
|
python.sdk.unpacking.pre.generated.skeletons=Unpacking pre-generated skeletons...
|
|
python.sdk.popup.interpreter.settings=Interpreter Settings...
|
|
python.sdk.popup.add.interpreter=Add Interpreter...
|
|
python.sdk.switch.to=Switch to {0}
|
|
python.sdk.installing=Installing {0}
|
|
python.sdk.downloading=Downloading {0}
|
|
python.sdk.running=Running {0}
|
|
python.sdk.installing.windows.warning=Windows may require your approval to install Python. Please check the taskbar.
|
|
python.sdk.select.conda.path.title=Select Path to Conda Executable
|
|
python.sdk.conda.path=Conda executable:
|
|
python.sdk.select.location.for.conda.title=Select Location for Conda Environment
|
|
python.sdk.environment.yml.chooser=Choose environment.yml
|
|
python.sdk.environment.yml.label=environment.yml
|
|
python.sdk.creating.conda.environment.sentence=Creating Conda environment
|
|
python.sdk.creating.conda.environment.title=Creating Conda Environment
|
|
python.sdk.add.python.interpreter.title=Add Python Interpreter
|
|
python.sdk.python.interpreter.title.0=Python Interpreter: {0}
|
|
python.sdk.new.environment.kind=New {0} environment
|
|
python.sdk.next=Next
|
|
python.sdk.previous=Previous
|
|
python.sdk.finish=Finish
|
|
python.sdk.setting.up.pipenv.sentence=Setting up pipenv environment
|
|
python.sdk.setting.up.pipenv.title=Setting Up Pipenv Environment
|
|
python.sdk.install.requirements.from.pipenv.lock=Install requirements from Pipfile.lock
|
|
python.sdk.pipenv.executable.not.found=Pipenv executable is not found
|
|
python.sdk.pipenv.executable=Pipenv executable:
|
|
python.sdk.pipenv.select.executable.title=Select Path to Pipenv Executable
|
|
python.sdk.pipenv.associated.project=Associated project:
|
|
python.sdk.pipenv.associated.module=Associated module:
|
|
python.sdk.pipenv.execution.exception.no.project.message=Cannot find the project associated with this Pipenv environment
|
|
python.sdk.pipenv.execution.exception.no.pipenv.message=Cannot find Pipenv
|
|
python.sdk.pipenv.execution.exception.error.running.pipenv.message=Error Running Pipenv
|
|
python.sdk.pipenv.quickfix.fix.pipenv.name=Fix Pipenv interpreter
|
|
python.sdk.pipenv.quickfix.use.pipenv.name=Use Pipenv interpreter
|
|
python.sdk.pipenv.pip.file.lock.not.found=Pipfile.lock is not found
|
|
python.sdk.pipenv.pip.file.lock.out.of.date=Pipfile.lock is out of date
|
|
python.sdk.pipenv.pip.file.notification.content=Run <a href='#lock'>pipenv lock</a> or <a href='#update'>pipenv update</a>
|
|
python.sdk.pipenv.pip.file.notification.locking=Locking Pipfile
|
|
python.sdk.pipenv.pip.file.notification.updating=Updating Pipenv environment
|
|
python.sdk.pipenv.pip.file.watcher=Pipfile Watcher
|
|
|
|
python.sdk.file.not.found=File {0} is not found
|
|
python.sdk.cannot.execute=Cannot execute {0}
|
|
python.sdk.pipenv.has.been.selected=Pipenv interpreter has been already added, select ''{0}'' in your interpreters list
|
|
python.sdk.there.is.no.interpreter=No interpreter
|
|
python.sdk.no.interpreter.configured.warning=No Python interpreter configured for the project
|
|
python.sdk.no.interpreter.selection=No Python interpreter selected
|
|
python.sdk.choose.valid.interpreter=Choose valid Python interpreter
|
|
python.sdk.common.options.environment=Environment
|
|
python.sdk.rendering.project.default=Project Default
|
|
python.sdk.rendering.project.default.0=Project Default ({0})
|
|
python.sdk.failed.to.install.title=Failed To Install {0}
|
|
python.sdk.installation.has.been.cancelled.title={0} Installation Has Been Cancelled
|
|
python.sdk.directory.not.found=Directory {0} not found
|
|
python.sdk.failed.to.create.interpreter.title=Failed To Create Interpreter
|
|
python.sdk.can.t.obtain.python.version=Can't obtain python version
|
|
python.sdk.executable.not.found.header=Python executable is not found. Choose one of the following options:
|
|
python.sdk.executable.not.found.option.specify.path=Click {0} to specify a path to python.exe in your file system
|
|
python.sdk.executable.not.found.option.download.and.install=Click {0} to download and install Python from python.org ({1})
|
|
python.sdk.admin.permissions.needed.consider.creating.venv=<html><strong>Note:</strong> You'll need admin permissions to install packages for this interpreter. Consider creating a per-project virtual environment instead.</html>
|
|
python.sdk.try.to.install.python.manually=Try to install Python from https://www.python.org manually.
|
|
python.sdk.consider.installing.python.manually=Consider installing Python from https://www.python.org manually.
|
|
python.sdk.some.installed.python.components.might.get.inconsistent.after.cancellation=Some Python components that have been installed might get inconsistent after cancellation.
|
|
python.sdk.failed.to.install.timed.out=Timed out
|
|
python.sdk.failed.to.install.exit.code=Exit code {0}
|
|
python.sdk.invalid.python.sdk=Invalid Python SDK
|
|
python.sdk.cannot.setup.sdk=Cannot set up a python SDK \nat {0}.\nThe SDK seems invalid.
|
|
|
|
# SDK / skeletons
|
|
sdk.some.skeletons.failed=Some skeletons failed to generate
|
|
sdk.gen.cleaning.up=Cleaning up skeletons...
|
|
sdk.gen.launching.generator=Launching skeleton generator...
|
|
sdk.gen.reloading=Reloading generated skeletons...
|
|
sdk.gen.unpacking.prebuilt=Unpacking prebuilt skeletons...
|
|
sdk.gen.updating.interpreter=Updating Python interpreter
|
|
sdk.scanning.installed.packages=Scanning Installed Packages
|
|
sdk.gen.stubs.for.binary.modules=Generate stubs for binary module {0}
|
|
sdk.gen.failed.notification.title=Couldn't refresh skeletons for remote interpreter
|
|
sdk.gen.cannot.create.skeleton.dir=Can''t create skeleton dir {0}
|
|
sdk.updating.interpreter.paths=Updating interpreter paths...
|
|
sdk.updating.interpreter.version=Updating interpreter version...
|
|
|
|
# Active SDK configurable and related dialogs
|
|
active.sdk.dialog.show.all.item=Show All...
|
|
active.sdk.dialog.project.interpreter=Python Interpreter:
|
|
active.sdk.dialog.project.interpreter.path.mappings=Path mappings:
|
|
active.sdk.dialog.project.interpreter.path.mappings.default.project.error=Open or create project to configure mappings
|
|
|
|
sdk.details.step.add=Add...
|
|
sdk.details.step.show.all=Show All...
|
|
|
|
sdk.details.dialog.title=Python Interpreters
|
|
sdk.details.dialog.hide.all.virtual.envs=Hide virtual environments associated with other projects
|
|
sdk.details.dialog.show.interpreter.paths=Show paths for the selected interpreter
|
|
sdk.details.dialog.error.duplicate.name=Please specify a unique name for the interpreter
|
|
|
|
sdk.edit.dialog.title=Edit Python Interpreter
|
|
sdk.edit.dialog.associate.virtual.env.with.path=Associate this virtual environment with {0}
|
|
sdk.edit.dialog.associate.virtual.env.current.project=Associate this environment with current project
|
|
sdk.edit.dialog.specify.interpreter.path=Specify Interpreter Path
|
|
|
|
sdk.paths.dialog.title=Interpreter Paths
|
|
sdk.paths.dialog.reload.paths=Reload List of Paths
|
|
sdk.paths.dialog.added.by.user.suffix=(added by user)
|
|
sdk.paths.dialog.removed.by.user.suffix=(removed by user)
|
|
|
|
sdk.create.venv.dependencies.label=Dependencies:
|
|
sdk.create.venv.dependencies.chooser=Choose requirements.txt or setup.py
|
|
|
|
sdk.create.venv.dialog.label.inherit.global.site.packages=Inherit global site-packages
|
|
sdk.create.venv.conda.dialog.label.location=Location:
|
|
sdk.create.venv.conda.dialog.label.python.version=Python version:
|
|
|
|
# remote interpreters
|
|
remote.interpreter.configure.title=Configure Remote Python Interpreter
|
|
remote.interpreter.configure.path.title=Select Python Interpreter
|
|
remote.interpreter.configure.temp.files.path.title=Select Folder for PyCharm Helpers
|
|
remote.interpreter.default.interpreter.path=/usr/bin/python
|
|
remote.interpreter.wsl.default.interpreter.path=/usr/bin/python
|
|
remote.interpreter.docker.default.interpreter.path=python
|
|
remote.interpreter.unspecified.interpreter.path=Specify Python interpreter path
|
|
remote.interpreter.unspecified.temp.files.path=Specify path for PyCharm helpers
|
|
remote.interpreter.configure.path.label=Python interpreter path:
|
|
remote.interpreter.configure.temp.files.path.label=PyCharm helpers path:
|
|
remote.interpreter.configure.ssh.run_as_root_via_sudo.checkbox=Execute code using this interpreter with root privileges via sudo
|
|
remote.interpreter.configure.ssh.run_as_root_via_sudo.help=Sudo will be invoked only for launching remote interpreters through SSH connections. Files will be copied to the remote server with user's privileges.
|
|
remote.interpreter.unsupported.python.sdk.type=Unsupported Python SDK type
|
|
remote.interpreter.support.is.not.available=Support for {0} is not available.\nPlease check the corresponding plugin.
|
|
remote.interpreter.remote.server.permissions=Failed to browse remote server. Make sure you have permissions.
|
|
remote.interpreter.accessing.remote.interpreter.progress.title=Accessing Remote Interpreter
|
|
|
|
# CommandLine
|
|
commandLine.inspection.name=Command-line inspection
|
|
commandLine.inspection.badCommand=Bad or unknown command. make sure this command really exists.
|
|
commandLine.inspection.badOption=Bad or unknown option. make sure this option really exists.
|
|
commandLine.inspection.badArgument=Argument can't have this value. use autocompletion to check list of possible values.
|
|
commandLine.inspection.excessArgument=Excess argument or argument is not possible here
|
|
# What to display of user entered junk
|
|
commandLine.commandNotFound={0}: command not found
|
|
|
|
# Window with actions
|
|
# "X" button title
|
|
windowWithActions.closeWindow=Close window
|
|
# "Stop" button title
|
|
windowWithActions.stopProcess=Stop currently running process
|
|
|
|
formatter.imports.panel.title=Imports
|
|
formatter.imports.panel.optimize.imports=Optimize Imports
|
|
formatter.imports.panel.sort.imports=Sort import statements
|
|
formatter.imports.panel.sort.names.in.from.imports=Sort imported names in "from" imports
|
|
formatter.imports.panel.from.imports.structure.title=Structure of "from" imports
|
|
formatter.imports.panel.from.imports.leave.as.is=Leave as is
|
|
formatter.imports.panel.from.imports.join.with.same.source=Join imports with the same source
|
|
formatter.imports.panel.from.imports.always.split=Always split imports
|
|
formatter.imports.panel.sort.by.type=Sort plain and "from" imports separately within a group
|
|
formatter.imports.panel.sort.case.insensitively=Sort case-insensitively
|
|
|
|
formatter.panel.dict.alignment.label=Dict alignment:
|
|
formatter.panel.add.trailing.line.feed=Add line feed at the end of file
|
|
|
|
formatter.panel.use.continuation.indent.for.title=Use continuation indent for
|
|
formatter.panel.use.continuation.indent.for.arguments=Method call arguments
|
|
formatter.panel.use.continuation.indent.for.collection.literals=Collections and comprehensions
|
|
|
|
formatter.left.bracket = Left bracket
|
|
formatter.around.eq.in.named.parameter = Around = in named parameter
|
|
formatter.around.eq.in.keyword.argument = Around = in keyword argument
|
|
formatter.braces = Braces
|
|
formatter.before.backslash = Before '\\'
|
|
formatter.before.hash = Before '#'
|
|
formatter.after.hash = After '#'
|
|
formatter.around.top.level.imports = After top-level imports:
|
|
formatter.after.local.imports=After local imports:
|
|
formatter.before.first.method=Before the first method:
|
|
formatter.around.top.level.classes.and.function=Around top-level classes and functions:
|
|
formatter.around.multiplicative.operators=Multiplicative operators (*, @, /, %)
|
|
formatter.around.power.operator=Power operator (**)
|
|
formatter.single.clause.statements=Single-clause statements
|
|
formatter.multi.clause.statements=Multi-clause statements
|
|
formatter.force.new.line.after.colon=Force new line after colon
|
|
formatter.align.when.multiline=Align when multiline
|
|
formatter.collections.and.comprehensions=Collections and Comprehensions
|
|
formatter.from.import.statements="From" Import Statements
|
|
formatter.from.import.statements.force.parentheses.if.multiline=Force parentheses if multiline
|
|
formatter.from.import.statements.force.comma.if.multline=Force trailing comma if multiline
|
|
formatter.dictionary.literals=Dictionary literals
|
|
formatter.hang.closing.brackets=Hang closing brackets
|
|
|
|
smartKeys.insert.backslash.in.statement.on.enter=Insert backslash when pressing Enter inside a statement
|
|
smartKeys.insert.self.in.method=Insert 'self' when defining a method
|
|
smartKeys.insert.type.placeholder.in.docstring.stub=Insert type placeholders in the documentation comment stub
|
|
|
|
show.expression.type.no.expression.found=No expression found
|
|
remote.interpreter.failed.to.obtain.credentials=Failed to obtain connection credentials for Python SDK {0}
|
|
|
|
action.SetNextStatement.text=&Jump To Cursor
|
|
action.SetNextStatement.description=Jump to the line where the caret is
|
|
action.StepIntoMyCode.text=Step Into My Code
|
|
action.StepIntoMyCode.description=Step to the next line executed ignoring libraries
|
|
action.PyConvertPackageToModuleAction.text=Convert to Python Module
|
|
action.PyConvertPackageToModuleAction.description=Create module with the same name and move content of __init__.py to that module
|
|
action.PyConvertModuleToPackage.text=Convert to Python Package
|
|
action.PyConvertModuleToPackage.description=Create package with the same name and move content of the module to its __init__.py
|
|
action.PyDebugger.ViewAsGroup.text=View as
|
|
action.PyDebugger.ViewArray.text=View as Array
|
|
action.PythonGenerateDictionaries.text=Generate Python Spellchecker Dictionaries
|
|
group.PyPackagingMenu.text=Packaging
|
|
action.CleanPyc.text=Clean Python Compiled Files
|
|
action.CleanPyc.description=Delete compiled bytecode files in selected directory and its subdirectories
|
|
action.CleanPyc.status.bar.text.deleted.bytecode.files=Deleted {0} bytecode {0,choice,0#files|1#file|2#files}
|
|
action.CleanPyc.progress.title.cleaning.up.pyc.files=Cleaning up .pyc files...
|
|
action.PySyncPythonRequirements.text=Sync Python Requirements...
|
|
action.PySyncPythonRequirements.description=Synchronize Python requirements file with the packages that are used in project
|
|
action.CompuleQrc.text=Compile .qrc file
|
|
action.NewPythonPackage.text=Python Package
|
|
action.NewPythonPackage.description=Create a new directory and __init__.py inside it
|
|
action.PyConsoleRenameAction.text=Rename Console
|
|
action.ExecuteInPyConsoleAction.text=Execute selection in console
|
|
action.ExecuteInPyConsoleAction.description=Executes selected code fragment in Python/Django console
|
|
action.com.jetbrains.python.console.RunPythonOrDebugConsoleAction.text=Python or Debug Console
|
|
action.com.jetbrains.python.console.RunPythonOrDebugConsoleAction.description=Allows to quickly run Python Console or Debug Console if debug session is running
|
|
action.ForceStepInto.text=Fo_rce Step Into
|
|
action.ForceStepInto.description=Step into, ignore stepping filters for libraries, constructors, etc.
|
|
configurable.Tab.display.name=Buildout
|
|
configurable.PyConsoleOptionsConfigurable.display.name=Console
|
|
configurable.PyConsoleOptionsConfigurable.child.display.name=Python Console
|
|
configurable.BuildoutConfigurable.display.name=Buildout
|
|
configurable.BuildoutModulesConfigurable.display.name=Buildout Support
|
|
configurable.PySmartKeysOptions.display.name=Python
|
|
configurable.PyContentEntriesModuleConfigurable.display.name=Project Structure
|
|
configurable.PythonContentEntriesConfigurable.display.name=Project Structure
|
|
configurable.PyDependenciesConfigurable.display.name=Project Dependencies
|
|
configurable.PyIntegratedToolsConfigurable.display.name=Python Integrated Tools
|
|
configurable.PyIntegratedToolsModulesConfigurable.display.name=Python Integrated Tools
|
|
configurable.PythonSdkEditorTab.display.name=Python SDK
|
|
configurable.PyDebuggerConfigurable.display.name=Python Debugger
|
|
configurable.PyActiveSdkModuleConfigurable.python.interpreter.display.name=Python Interpreter
|
|
configurable.PyLanguageCodeStyleSettingsProvider.display.name=Python
|
|
flask.name=Flask
|
|
settings.default.remote.interpreter=Default Python Remote Interpreter
|
|
action.DumbAware.PydevConsoleRunnerImpl.text.stop.console=Stop Console
|
|
action.DumbAware.PydevConsoleRunnerImpl.description.stop.python.console=Stop Python Console
|
|
action.DumbAware.ConcurrencyToolWindowPanel.text.stop.process=Stop process
|
|
action.DumbAware.ConcurrencyToolWindowPanel.description.stop.process=Stop process
|
|
action.AnActionButton.text.use.conda.package.manager=Use Conda Package Manager
|
|
action.AnActionButton.text.show.early.releases=Show Early Releases
|
|
action.PyManagePackages.text=Manage Python Packages...
|
|
action.RunPythonToolwindowAction.text=Python Console
|
|
|
|
# qt actions
|
|
qt.error.failed.run.qt.designer=Failed to run Qt Designer: {0}
|
|
qt.qrc.compiler.select.output.path=Select Output Path:
|
|
qt.qrc.compile.files=Compile {0} .qrc Files
|
|
qt.qrc.compile=Compile {0}
|
|
qt.compile.qrc.file=Compile .qrc File
|
|
qt.run.tab.title.compile.qrc=Compile .qrc
|
|
qt.run.error=Error running {0}: {1}
|
|
qt.cannot.find.pyrcc4.or.pysidercc=Could not find pyrcc4 or pyside-rcc for selected Python interpreter
|
|
qt.run.designer.error=Error
|
|
qt.ui.designer.form.filetype.description=Qt UI Designer form
|
|
|
|
python.module.name=Python Module
|
|
python.module.description=Python modules are used for developing <b>Python</b> applications.
|
|
python.module.description.extended=Supported technologies include <b>Django, Google App Engine, Mako, Jinja2</b> and others.
|
|
|
|
action.create.python.file.title=Python File
|
|
action.create.python.file.description=Creates a Python file from the specified template
|
|
acton.run.file.in.python.console.title=Run File in Python Console
|
|
action.run.file.in.python.console.description=Run current file in Python console
|
|
|
|
buildout.facet.title=Buildout Support
|
|
buildout.configurable.choose.a.buildout.script=Choose a Buildout Script
|
|
buildout.configurable.select.the.target.script=Select the target script that will invoke your code
|
|
buildout.color.comment=Comment
|
|
buildout.color.key.value.separator=Key value separator
|
|
buildout.color.value=Value
|
|
buildout.color.key=Key
|
|
buildout.color.section.name=Section name
|
|
buildout.config=Buildout config
|
|
buildout.config.language=Buildout config
|
|
buildout.config.script.name.validation.error.message=Please specify buildout script
|
|
buildout.config.script.file.invalid.message=Invalid script file ''{0}''
|
|
|
|
code.insight.goto.superclass.attribute.chooser.title=Choose superclass attribute
|
|
|
|
code.insight.select.methods.to.override=Select Methods to Override
|
|
code.insight.select.methods.to.implement=Select Methods to Implement
|
|
code.insight.stub.package.advertiser.notifications.group.title=Python Stub Packages Advertiser
|
|
code.insight.create.test=Create test
|
|
code.insight.select.target.directory=Select target directory
|
|
code.insight.encoding.comment.format=Encoding comment format:
|
|
code.insight.select.default.encoding=Select default encoding:
|
|
code.insight.stub.forced.packages.are.not.installed.message=Stub {0,choice,1#package|2#packages} {1} {0,choice,1#is|2#are} not installed. \
|
|
{0,choice,1#It|2#They} {0,choice,1#contains|2#contain} type hints needed for better code insight.
|
|
code.insight.stub.checked.packages.are.not.installed.message=Stub {0,choice,1#package|2#packages} {1} {0,choice,1#is|2#are} not installed
|
|
code.insight.stub.packages.ignored.notification.content=Suggested {0} {1,choice,1#is|2#are} incompatible with your current environment.\n\
|
|
{1,choice,1#This|2#These} stub {1,choice,1#package|2#packages} will be removed and ignored until new version is released.
|
|
code.insight.stub.packages.install.requirements.fix.name=Install stub {0,choice,1#package|2#packages}
|
|
code.insight.type.hints.are.not.installed=Type hints are not installed
|
|
code.insight.install.type.hints.content=They could make code insight better.
|
|
code.insight.install.type.hints.action=Install stub packages
|
|
code.insight.ignore.type.hints=Ignore
|
|
code.insight.ignore.packages.qfix=Ignore {0,choice, 1#package|2#packages}
|
|
configurable.pipenv.auto.detected=Auto-detected: {0}
|
|
configurable.choose.path.to.the.package.requirements.file=Choose path to the package requirements file:
|
|
configurable.choose.working.directory=Please choose working directory:
|
|
configurable.select.working.directory=Select Working Directory
|
|
|
|
console.waiting.execution.result=Waiting for execution result
|
|
console.getting.from.runtime=Getting {0} from Python Runtime
|
|
console.getting.completion=Completion
|
|
console.getting.documentation=Documentation
|
|
console.getting.frame.variables=Frame Variables
|
|
console.getting.variable.value=Variable Value
|
|
console.getting.array=Array
|
|
console.evaluating.expression.in.console=Evaluating expression in console
|
|
console.connecting.to.debugger=Connecting To debugger
|
|
console.changing.variable=Changing variable
|
|
console.interrupting.execution=Interrupting execution
|
|
console.close.console.communication=Close console communication
|
|
console.executing.code.in.console=Executing Code in Console...
|
|
console.new.console.description=Creates new python console
|
|
console.new.console=New Console
|
|
console.error.connecting.debugger=Error Connecting Debugger
|
|
console.cannot.connect.to.debugger=Can't connect to debugger
|
|
console.attach.debugger.description=Enables tracing of code executed in console
|
|
console.attach.debugger=Attach Debugger
|
|
console.restarting.console=Restarting Console
|
|
console.stopping.console=Stopping Console
|
|
connecting.to.console.progress=Connecting to console...
|
|
connecting.to.console.title=Connecting to Console
|
|
console.show.variables.title=Show Variables
|
|
console.show.variables.description=Shows active console variables
|
|
console.executing.dataviewer.command="Executing DataViewer command"
|
|
|
|
form.debugger.save.call.signatures=Save call signatures
|
|
|
|
compile.cython.extensions.title=Compile Cython extensions
|
|
compile.cython.extensions.help=How does it work
|
|
compile.cython.extensions.install=Install
|
|
compile.cython.extensions.notification=Python Debugger Extension Available
|
|
compile.cython.extensions.error=Compile Cython Extensions Error
|
|
|
|
create.python.file.action.new.python.file=New Python file
|
|
create.python.file.action.python.file=Python file
|
|
create.python.file.action.python.unit.test=Python unit test
|
|
create.python.file.action.python.stub=Python stub
|
|
create.python.file.script.action=Create Python script {0}
|
|
|
|
debugger.attach.to.process.filter.names=<html>For <b>Attach To Process</b> show processes with names containing:</html>
|
|
debugger.attach.to.process.failed.to.find.free.socket.port=Failed to find free socket port
|
|
debugger.watch.return.values.description=Enables watching executed functions return values
|
|
debugger.exception.breakpoint.ignore.library.files=Ignore library files
|
|
debugger.exception.breakpoint.on.raise=On raise
|
|
debugger.exception.breakpoint.on.termination=On termination
|
|
debugger.exception.breakpoint.type=Python Exception Breakpoint
|
|
debugger.exception.breakpoint.activation.policy=Activation policy
|
|
debugger.exception.breakpoint.any.exception=Any exception
|
|
debugger.line.breakpoint.type=Python Line Breakpoint
|
|
debugger.delete.signature.cache=Delete Cache
|
|
debugger.simplified.view.description=Disables watching classes, functions and modules objects
|
|
debugger.simplified.view.text=Simplified Variables View
|
|
debugger.data.view.colored=Colored
|
|
debugger.data.view.close.selected.viewer=Close selected viewer
|
|
debugger.data.view.close.viewer=Close Viewer
|
|
debugger.data.view.open.new.container.viewer=Open new container viewer
|
|
debugger.data.view.view.new.container=View New Container
|
|
debugger.data.view.data=Data
|
|
debugger.data.view.close=Close
|
|
debugger.data.view.resize.automatically=Resize automatically
|
|
debugger.data.view.colored.cells=Colored cells
|
|
debugger.data.view.failed.to.evaluate.expression=Failed to evaluate expression {0}
|
|
debugger.data.view.type.is.not.supported={0} is not supported
|
|
debugger.data.view.empty.tab="Empty"
|
|
debugger.numeric.view.as.dataframe=View as DataFrame
|
|
debugger.numeric.view.as.array=View as Array
|
|
debugger.numeric.view.as.series=View as Series
|
|
debugger.stepping.filter=Stepping Filter
|
|
debugger.stepping.filter.specify.pattern=Specify glob pattern ('*', '?' and '[seq]' allowed, semicolon ';' as name separator):
|
|
debugger.stepping.no.script.filters=No script filters configured
|
|
debugger.sending.close.message=Sending close message to Python Console...
|
|
debugger.waiting.to.finish=Waiting for Python Console process to finish...
|
|
debugger.variables.loading.policy=Variables Loading Policy
|
|
debugger.variables.loading.synchronously.text=Synchronously
|
|
debugger.variables.loading.synchronously.description=Load variable values synchronously
|
|
debugger.variables.loading.asynchronously.text=Asynchronously
|
|
debugger.variables.loading.asynchronously.description=Load variable values asynchronously
|
|
debugger.variables.loading.on.demand.text=On demand
|
|
debugger.variables.loading.on.demand.description=Load variable values on demand
|
|
debugger.variables.view.loading.timed.out=Loading timed out
|
|
debugger.variables.view.switch.to.loading.on.demand=Switch to loading on demand
|
|
debugger.variables.view.warning.message=The values of several variables couldn't be loaded
|
|
debugger.exception.breakpoint.select.exception.class=Select Exception Class
|
|
debugger.watch.show.return.values=Show Return Values
|
|
debugger.data.view.connected.to.python.console=Connected to python console
|
|
debugger.data.view.connected.to.debug.session=Connected to debug session ''{0}''
|
|
debugger.data.view.empty.text=Run Python Console or Debugger to view available data
|
|
debugger.stack.frame.special.variables=Special Variables
|
|
debugger.stack.frame.return.values=Return Values
|
|
debugger.stack.frame.frame.not.available=<frame not available>
|
|
debugger.stack.frame.unable.to.display.frame.variables=Unable to display frame variables
|
|
debugger.stack.frames.not.available.in.non.suspended.state=Frames not available in non-suspended state
|
|
debugger.test.failed.caption=Test failed
|
|
debugger.error.in.test.setup.or.teardown.caption=Error in test set up or tear down
|
|
debugger.remote.port.out.of.boundaries=Port number is out of boundaries
|
|
|
|
debugger.dataviewer.action.export.name=Export...
|
|
debugger.dataviewer.action.export.dialog.description=Save to
|
|
debugger.dataviewer.export.error.title=Table export failed
|
|
debugger.dataviewer.export.error.invalid.filepath=Invalid filepath
|
|
debugger.dataviewer.export.error.invalid.filepath.content=Filepath ''{0}'' is invalid
|
|
debugger.dataviewer.export.error.unhandled=Unhandled error
|
|
debugger.dataviewer.export.error.unhandled.content=Couldn''t export to ''{0}'':\n{1}
|
|
debugger.dataviewer.notification.group.title=Data Viewer error
|
|
debugger.dataviewer.action.copy.name=Copy
|
|
debugger.dataviewer.action.set.filter.name=Set Filter...
|
|
debugger.dataviewer.action.set.filter.description=Filter on Column ''{0}''
|
|
debugger.dataviewer.action.set.filter.use.regex=Use RegEx
|
|
debugger.dataviewer.action.set.filter.button.set=Set
|
|
debugger.dataviewer.action.set.filter.item.expression=Expression
|
|
debugger.dataviewer.action.set.filter.item.substring=Substring
|
|
debugger.dataviewer.action.set.filter.help.expression=<html>Use <b>{0}</b> as variable for lambda function</html>
|
|
debugger.dataviewer.action.set.filter.ad.controls=Press Enter to apply
|
|
debugger.dataviewer.action.goto.dialog.title=Go To
|
|
debugger.dataviewer.action.goto.dialog.label=Row:Column
|
|
debugger.dataviewer.action.copy.properties.name=Copy to Clipboard Settings
|
|
debugger.dataviewer.action.copy.properties.dialog.title=Copy to Clipboard Settings
|
|
debugger.dataviewer.action.copy.properties.include.header=Include header
|
|
debugger.dataviewer.action.copy.properties.include.indices=Include indices
|
|
debugger.dataviewer.action.copy.properties.separator=Separator:
|
|
debugger.dataviewer.action.copy.update.message=Copy to clipboard
|
|
debugger.dataviewer.action.remove.filter.name=Remove Filter
|
|
debugger.dataviewer.action.open.in.editor.name=Open in Editor Tab
|
|
debugger.dataviewer.modifier.error=Modifier error: {0}
|
|
debugger.dataviewer.header.filter.hint={0}: {1}
|
|
debugger.dataviewer.header.filter.hint.mode.expression=Expression
|
|
debugger.dataviewer.header.filter.hint.mode.regex=RegEx
|
|
debugger.dataviewer.header.filter.hint.mode.substring=Substring
|
|
|
|
debugger.remote.waiting.for.process.connection=Waiting for process connection...
|
|
debugger.remote.waiting.for.connection=Waiting for connection
|
|
debugger.cython.python.run.configuration.should.be.selected=Python Run Configuration should be selected
|
|
debugger.cython.extension.speeds.up.python.debugging=Cython extension speeds up Python debugging
|
|
debugger.cython.extension.permission.denied=Permission denied
|
|
debugger.cython.extension.non.zero.exit.code=Non-zero exit code ({0}): \n{1}
|
|
debugger.cython.please.enter.your.password.to.compile.cython.extensions=Please enter your password to compile cython extensions:
|
|
debugger.warning.message=This option may slow down the debugger
|
|
debugger.connected.to.pydev.debugger.build=Connected to pydev debugger (build {0})\n
|
|
debugger.warning.wrong.debugger.version=Warning: wrong debugger version. Use pycharm-debugger.egg from PyCharm installation folder\nOr execute: 'pip install pydevd-pycharm~=%{0}'\n
|
|
debugger.pydev.console.pause.the.process.to.use.command.line=Pause the process to use command-line.
|
|
debugger.debug.process.disconnected=Disconnected
|
|
debugger.debug.process.running=Process is running
|
|
debugger.remote.starting.debug.server.at.port=Starting debug server at port {0}\n
|
|
debugger.use.the.following.code.to.connect.to.the.debugger=Use the following code to connect to the debugger:\n
|
|
|
|
python.local.attach.group.name=Python
|
|
|
|
pydev.console.runner.settings=Settings
|
|
pydev.console.runner.error.running.console=Error running console
|
|
pydev.console.runner.python.console.debugger=Python Console Debugger
|
|
pydev.console.runner.unknown.error=Unknown error
|
|
pydev.console.console.process.terminated.with.error=Console process terminated with error:\n{0}{1}
|
|
pydev.console.console.process.terminated.with.exit.code=Console process terminated with exit code {0}, output:{1}
|
|
pydev.console.couldnt.connect.to.console.process=Couldn't connect to console process.
|
|
pydev.console.debugger.connected=\nDebugger connected.\n
|
|
pydev.console.couldnt.read.integer.value.from.stream=Couldn't read integer value from stream
|
|
pydev.console.python.interpreter.is.not.selected=Python interpreter is not selected. Please setup Python interpreter first.
|
|
|
|
external.documentation.python.plugin=Python External Documentation
|
|
external.documentation.pycharm=External Documentation
|
|
external.documentation.edit.documentation.url=Edit Documentation URL
|
|
external.documentation.title=Python External Documentation
|
|
external.documentation.configure.description=No external documentation URL configured for module {0}.\nWould you like to configure it now?
|
|
external.documentation.column.name.module=Module Name
|
|
external.documentation.column.name.url.path.pattern=URL/Path Pattern
|
|
|
|
|
|
python.colors.python=Python
|
|
python.colors.type.annotation=Type annotation
|
|
python.colors.class.definition=Class definition
|
|
python.colors.decorator=Decorator
|
|
python.colors.built.in.name=Built-in name
|
|
python.colors.special.names.usage=Special Names//Usage
|
|
python.colors.special.names.definition=Special Names//Definition
|
|
python.colors.keyword.argument=Keyword argument
|
|
python.colors.parameters.self.parameter=Parameters//'self' parameter
|
|
python.colors.parameters.parameter=Parameters//Parameter
|
|
python.colors.functions.method.call=Functions//Method call
|
|
python.colors.functions.nested.function.definition=Functions//Nested function definition
|
|
python.colors.functions.function.call=Functions//Function call
|
|
python.colors.functions.function.definition=Functions//Function definition
|
|
python.colors.braces.and.operators.dot=Braces and Operators//Dot
|
|
python.colors.braces.and.operators.comma=Braces and Operators//Comma
|
|
python.colors.braces.and.operators.braces=Braces and Operators//Braces
|
|
python.colors.braces.and.operators.brackets=Braces and Operators//Brackets
|
|
python.colors.braces.and.operators.parentheses=Braces and Operators//Parentheses
|
|
python.colors.braces.and.operators.operation.sign=Braces and Operators//Operation sign
|
|
python.colors.docstring.tag=Docstring//Tag
|
|
python.colors.docstring.text=Docstring//Text
|
|
python.colors.string.f.string.format.specifier.start=String//f-string//Format specifier start
|
|
python.colors.string.f.string.type.conversion=String//f-string//Type conversion
|
|
python.colors.string.f.string.expression.braces=String//f-string//Expression braces
|
|
python.colors.string.escape.sequence.invalid=String//Escape sequence//Invalid
|
|
python.colors.string.escape.sequence.valid=String//Escape sequence//Valid
|
|
python.colors.string.text.unicode=String//Text (unicode)
|
|
python.colors.string.binary.bytes=String//Binary (bytes)
|
|
python.colors.line.comment=Line Comment
|
|
python.colors.keyword=Keyword
|
|
python.colors.number=Number
|
|
|
|
python.new.project.synchronization.not.configured.dialog.title=Synchronization not Configured
|
|
python.new.project.synchronization.not.configured.dialog.message=Local/Remote synchronization is not configured correctly.\n{0}\n\
|
|
You may need to sync local and remote project manually.\n\n \
|
|
Do you want to continue? \n\n\
|
|
Say ''Yes'' to stay with misconfigured mappings or ''No'' to start manual configuration process.
|
|
|
|
python.new.project.remote.path.not.provided=Remote path not provided
|
|
python.new.project.more.settings=Mor&e Settings
|
|
python.new.project.install.failed.title=Install {0} Failed
|
|
python.new.project.error.solution.another.sdk=Choose another SDK
|
|
|
|
python.project.view.remote.libraries=Remote Libraries
|
|
python.project.view.py.skeletons=Binary Skeletons
|
|
python.project.view.typeshed.stubs=Typeshed Stubs
|
|
python.project.view.user.skeletons.node=Extended Definitions
|
|
|
|
python.packaging.installing.packaging.tools=Installing packaging tools...
|
|
python.packaging.installing.packages=Installing packages...
|
|
python.packaging.warning=Warning
|
|
python.packaging.create.setup.py=Create setup.py
|
|
python.packaging.failed.to.run.task=Failed to run task: {0}
|
|
python.packaging.run.setup.py.task=Run setup.py Task...
|
|
python.packaging.expand.options=Expand Options >>
|
|
python.packaging.collapse.options=<< Collapse Options
|
|
python.packaging.run.setup.task.0=Run Setup Task {0}
|
|
python.packaging.enter.setup.py.task=Enter setup.py task name
|
|
python.packaging.no.tasks.found=No tasks found
|
|
python.packaging.command.line=Command Line
|
|
python.packaging.install=Install
|
|
python.packaging.choose.packages.to.install=Choose Packages to Install
|
|
python.packaging.removing.conda.channel=Removing Conda Channel
|
|
python.packaging.adding.conda.channel=Adding Conda Channel
|
|
python.packaging.failed.to.install.packaging.tools.title=Failed to Install Python Packaging Tools
|
|
python.packaging.install.packaging.tools=Install packaging tools
|
|
|
|
# Example of produced message:
|
|
# You are attempting to uninstall MarkupSafe package which is required for Jinja2 package
|
|
#
|
|
# Do you want to proceed?
|
|
python.packaging.dialog.description.attempt.to.uninstall.for.one.dependent.package.single.package.description=\
|
|
{0} package which is required for {1}
|
|
python.packaging.dialog.description.attempt.to.uninstall.for.one.dependent.package=\
|
|
You are attempting to uninstall {0} {1, choice, 1#package|2#packages}\n\n\
|
|
Do you want to proceed?
|
|
|
|
# Example of produced message:
|
|
# You are attempting to uninstall packages which are required for another packages.
|
|
#
|
|
# Jinja2 -> Flask
|
|
# muffin -> muffin-jinja2
|
|
#
|
|
# Do you want to proceed?
|
|
python.packaging.dialog.description.attempt.to.uninstall.for.several.dependent.packages.single.package.description={0} -> {1}
|
|
python.packaging.dialog.description.attempt.to.uninstall.for.several.dependent.packages=\
|
|
You are attempting to uninstall packages which are required for another packages.\n\n\
|
|
{0}\n\n\
|
|
Do you want to proceed?
|
|
|
|
python.packaging.notification.description.details.link=Details...
|
|
python.packaging.notification.description.installed.all.requirements=Installed all requirements
|
|
python.packaging.notification.description.installed.packages=Installed packages: {0}
|
|
python.packaging.notification.description.installed.python.packaging.tools=Installed Python packaging tools
|
|
python.packaging.notification.description.uninstalled.packages=Uninstalled packages: {0}
|
|
python.packaging.notification.title.error.occurred={0}: error occurred.
|
|
python.packaging.notification.title.install.packages.failed=Install packages failed
|
|
python.packaging.notification.title.packages.installed.successfully=Packages installed successfully
|
|
python.packaging.notification.title.packages.uninstalled.successfully=Packages uninstalled successfully
|
|
python.packaging.notification.title.uninstall.packages.failed=Uninstall packages failed
|
|
python.packaging.progress.text.installing.specific.package=Installing package ''{0}''...
|
|
python.packaging.progress.title.installing.packages=Installing packages
|
|
python.packaging.progress.title.uninstalling.packages=Uninstalling packages
|
|
python.packaging.failed.to.install.packages.title=Failed to Install Packages
|
|
|
|
python.unresolved.reference.inspection.install.package=Install package {0}
|
|
|
|
# UI forms
|
|
|
|
form.qt.compile.qrc.output.file=Output file:
|
|
form.buildout.config.set.to.buildout.dir.bin.django.py.for.proper.django.support=Set to <buildout-dir>/bin/django.py for proper Django support
|
|
form.buildout.config.use.paths.from.script=Use paths from &script:
|
|
form.auto.import.from.module.import.name=from <module> import <name>
|
|
form.auto.import.import.module.name=import <module>.<name>
|
|
form.auto.import.preferred.import.style=Preferred import style:
|
|
form.auto.import.python=Python
|
|
form.auto.import.auto.import.show.popup=Show import popup
|
|
form.create.test.target.directory=Target directory
|
|
form.create.test.test.class.name=Test class name
|
|
form.create.test.test.file.name=Test file name
|
|
form.edit.sdk.associate.this.virtual.environment.with.current.project=&Associate this virtual environment with current project
|
|
form.edit.sdk.interpreter.path=&Interpreter path:
|
|
form.edit.sdk.label.create.connection.pool.options.name=&Name:
|
|
form.edit.sdk.html.href.remove.association=<html><a href=\\"#\\">Remove association</a>
|
|
form.edit.smart.indent.pasted.lines=Smart indent pasted lines
|
|
form.integrated.tools.analyze.python.code.in.docstrings=Analyze Python code in docstrings
|
|
form.integrated.tools.default.test.runner=Default test runner:
|
|
form.integrated.tools.docstring.format=Docstring format:
|
|
form.integrated.tools.package.requirements.file=Package requirements file:
|
|
form.integrated.tools.path.to.pipenv.executable=Path to Pipenv executable:
|
|
form.integrated.tools.render.external.documentation.for.stdlib=Render external documentation for stdlib
|
|
form.integrated.tools.sphinx.working.directory=Sphinx working directory:
|
|
form.integrated.tools.treat.txt.files.as.restructuredtext=Treat *.txt files as reStructuredText
|
|
form.console.options.always.show.debug.console=Always show Debug Console
|
|
form.console.options.settings.title.system.settings=General settings
|
|
form.console.options.show.console.variables.by.default=Show console variables by default
|
|
form.console.options.use.existing.console.for.run.with.python.console=Use existing console for "Run with Python Console"
|
|
form.console.options.use.ipython.if.available=Use IPython if available
|
|
form.console.specific.options.starting.script=Starting script
|
|
form.debugger.for.attach.to.process.show.processes.with.names.containing=\ For Attach To Process show processes with names containing:
|
|
form.debugger.attach.to.subprocess.automatically.while.debugging=Attach to subprocess automatically while debugging
|
|
form.debugger.clear.caches=Clear caches
|
|
form.debugger.clear.caches.action=Clear caches
|
|
form.debugger.collect.run.time.types.information.for.code.insight=Collect run-time types information for code insight
|
|
form.debugger.gevent.compatible=Gevent compatible
|
|
form.debugger.drop.into.debugger.on.failed.tests=Drop into debugger on failed tests
|
|
form.debugger.pyqt.compatible=PyQt compatible
|
|
form.debugger.remote.interpreter.docker.default.interpreter.path=python
|
|
form.data.viewer.current.slice=Current slice.
|
|
form.data.viewer.dialog.show.svn.map.table.header.column.format.title=Format
|
|
form.data.viewer.format=Format:
|
|
form.debugger.stepping.checkbox.text.do.not.step.into.library.scripts=Do not step into library scripts
|
|
form.debugger.stepping.do.not.step.into.scripts=Do not step into scripts:
|
|
form.debugger.stepping.always.do.smart.step.into=Always do smart step into
|
|
form.documentation.entry.insert=&Insert
|
|
form.documentation.entry.module.name=&Module Name:
|
|
form.documentation.entry.url.path.pattern=&URL/Path Pattern:
|
|
form.documentation.entry.available.macros=Available Macros
|
|
form.remote.path.remote.project.location=Remote project location:
|
|
form.introduce.name=&Name:
|
|
form.introduce.field.initialize.in=&Initialize in
|
|
form.move.module.members.from=From:
|
|
form.move.module.members.to=To:
|
|
form.python.run.configuration.emulate.terminal.in.output.console=Emulate terminal in output console
|
|
form.python.run.configuration.redirect.input.from=Redirect input from:
|
|
form.python.run.configuration.run.with.python.console=Run with Python Console
|
|
form.test.shared.target=Target:
|
|
form.test.shared.test=Test
|
|
form.test.run.configuration.params=Params:
|
|
form.test.run.configuration.specify.nosetests.command.line.options=Specify nosetests command line options
|
|
form.test.run.configuration.unittest=Unittest
|
|
form.pytest.legacy.path.to.a.file.or.directory.that.contains.the.tests.to.be.executed=Path to a file or directory that contains the tests to be executed
|
|
form.pytest.legacy.py.tests=py.tests
|
|
form.pytest.legacy.specify.py.tests.command.line.options=Specify py.tests command line options
|
|
form.pytest.legacy.specify.the.keywords.to.search.for.the.required.tests.k.command.line.option.in.py.tests=Specify the keywords to search for the required tests. -k command line option in py.tests
|
|
form.tox.configuration.arguments=Arguments
|
|
form.tox.configuration.run.only.environment=Run only environment
|
|
form.tox.configuration.runcfg.tox=tox
|
|
py.module.dependencies.configurable.list.title=Project depends on these projects:
|
|
py.sdk.editor.python.interpreter.label.text=Python Interpreter:
|
|
# Python reStructuredText forms
|
|
rest.configuration.editor.open.output.file.in.browser.label.text=Open output file in browser
|
|
sphinx.ask.for.working.directory.label.text=Sphinx working directory
|
|
|
|
|
|
|
|
pure.python.project=Pure Python
|
|
project.cannot.be.generated=Project can not be generated
|
|
error.in.project.generation=Error in Project Generation
|
|
|
|
sdk.has.been.configured.as.the.project.interpreter={0} has been configured as the project interpreter
|
|
sdk.has.been.configured.notification.name=Configured Python interpreter
|
|
configuring.interpreters.link=<html><a href="#">Configure Interpreters
|
|
looking.for.previous.interpreter=Looking for the previously used interpreter
|
|
looking.for.related.venv=Looking for a virtual environment related to the project
|
|
looking.for.pipfile=Looking for a Pipfile
|
|
install.packages.from.pipfile=Install packages from Pipfile
|
|
looking.for.default.interpreter=Looking for the default interpreter setting for a new project
|
|
looking.for.previous.system.interpreter=Looking for the previously used system-wide interpreter
|
|
looking.for.system.interpreter=Looking for a system-wide interpreter
|
|
looking.for.shared.conda.environment=Looking for a shared Conda environment
|
|
current.interpreter=Current Interpreter: {0}
|
|
switch.python.interpreter=Switch Python Interpreter
|
|
python.facet.name=Python
|
|
choose.packages.to.install=Choose packages to install:
|
|
manage.python.packages=Manage Python Packages
|
|
available.to.all.projects=Make available to all projects
|
|
|
|
|
|
framework.support.python.sdk.combobox.label=Python SDK:
|
|
integrated.tools.configurable.docstrings=Docstrings
|
|
integrated.tools.configurable.restructuredtext=reStructuredText
|
|
integrated.tools.configurable.packaging=Packaging
|
|
integrated.tools.configurable.testing=Testing
|
|
integrated.tools.configurable.pipenv=Pipenv
|
|
command.line.parser.error.message=Space between argument and its value is unexpected
|
|
|
|
python.package.installation.notification.message={0} will be installed on the selected interpreter
|
|
python.package.and.packaging.tools.installation.notification.message=Python packaging tools and {0} will be installed on the selected interpreter
|
|
|
|
python.execute.selection.action.execute.selection.in.console=Execute Selection in Python Console
|
|
python.execute.selection.action.execute.line.in.console=Execute Line in Python Console
|
|
python.execute.selection.action.select.console.to.execute.in=Select Console to Execute in
|
|
|
|
python.add.sdk.panel.name.conda.environment=Conda environment
|
|
python.add.sdk.panel.name.existing.environment=Existing environment
|
|
python.add.sdk.panel.name.previously.configured.interpreter=Previously configured interpreter
|
|
python.add.sdk.panel.name.new.environment.using=New environment using
|
|
python.add.sdk.panel.name.new.environment=New environment
|
|
python.add.sdk.panel.name.new.project.interpreter=New project interpreter
|
|
python.add.sdk.panel.name.pipenv.environment=Pipenv Environment
|
|
python.add.sdk.panel.name.system.interpreter=System interpreter
|
|
python.add.sdk.panel.name.virtualenv.environment=Virtualenv environment
|
|
|
|
python.add.sdk.conda.executable.path.is.empty=Conda executable path is empty
|
|
python.add.sdk.conda.executable.not.found=Conda executable not found
|
|
python.add.sdk.conda.executable.path.is.not.executable=Conda executable path is not an executable file
|
|
|
|
python.requirements.version.label=Version in requirements:
|
|
python.requirements.version.separator.no.version=Don't specify version
|
|
python.requirements.version.separator.strong.eq=Strong equality
|
|
python.requirements.version.separator.gte=Greater or equal
|
|
python.requirements.version.separator.compatible=Compatible version
|
|
python.requirements.remove.unused=Remove unused requirements
|
|
python.requirements.modify.base.files=Modify base files (defined with -r or --requirement)
|
|
python.requirements.keep.matching.specifier=Keep existing version specifier if it matches the current version
|
|
python.requirements.analyzing.imports.title=Analyzing Imports in Project
|
|
python.requirements.action.name=Sync Python requirements
|
|
python.requirements.error.ends.with.slash=Error parsing requirements: file ends with '/' symbol.
|
|
python.requirements.error.no.interpreter=Configured interpreter required to synchronize requirements.
|
|
python.requirements.warning.unhandled.lines=Could not analyze entries in requirements fie: {0}
|
|
python.requirements.info.file.ref.dropped=Some requirements from base files were not updated: {0}
|
|
python.requirements.balloon=Sync Python requirements
|
|
|
|
toolwindow.stripe.SciView=SciView
|
|
toolwindow.stripe.Python_Console=Python Console
|
|
python.folding.options.title=Python
|
|
python.long.string.literals=Long string literals
|
|
python.long.collection.literals=Long collection literals
|
|
python.sequential.comments=Sequential comments
|
|
python.provide.a.qualified.name.of.a.module=Provide a qualified name of a module
|
|
python.input.file.doesn.t.exist=Input file doesn't exist
|
|
python.call.graph=Call Graph
|
|
python.buildout.failed.to.extract.path=Failed to extract paths from {0}
|
|
python.debugger.collection.signatures.deleted=Collected signatures were deleted
|
|
python.debugger.nothing.to.delete=Nothing to delete
|
|
python.debugger.qt.backend.auto=Auto
|
|
python.debugger.settings.waiting.for.connection=Waiting for connection...
|
|
python.debugger.settings.connecting.to.debugger=Connecting To debugger
|
|
python.debugger.attaching.to.process.with.pid=Attaching to a process with PID={0}
|
|
python.debugger.attaching=Attaching Debugger
|
|
python.rename.processor.override.message=Method {0} of class {1}\noverrides method of class {2}.\nDo you want to rename the base method?
|
|
python.rename.processor.property=Do you want to rename the property ''{0}'' instead of its accessor function ''{1}''?
|
|
python.configuration.choose.target.to.run=Choose target to run
|
|
python.vagrant.refresh.skeletons=Launch vagrant and refresh skeletons
|
|
python.concurrency.visualizer.scroll.end=Scroll to the End
|
|
python.execute.cell.in.console=Execute Cell in Console
|
|
python.template.select.file.type=Select File Type
|
|
python.execution.is.still.running=Previous execution is still running
|
|
|
|
INSP.settings.pep8.ignore.errors=Ignore errors
|
|
INSP.settings.bdd.behave.specific=BDD Behave-specific inspection
|
|
INSP.settings.bdd.step.definition.arguments=BDD step definition arguments inspection
|
|
python.compatibility.inspection.advertiser.notifications.group.title=Python compatibility inspection advertiser
|
|
python.compatibility.inspection.advertiser.notifications.title=Python versions compatibility
|
|
|
|
python.compatibility.inspection.advertiser.using.future.imports.warning.message=\
|
|
Your source code contains __future__ imports.<br/>\
|
|
Would you like to enable Code compatibility inspection?<br/>\
|
|
<a href="#yes">Yes</a>\\ \\ <a href="#no">No</a>
|
|
|
|
python.compatibility.inspection.advertiser.using.six.warning.message=\
|
|
Your source code imports the 'six' package.<br/>\
|
|
Would you like to enable Code compatibility inspection?<br/>\
|
|
<a href="#yes">Yes</a>\\ \\ <a href="#no">No</a>
|
|
|
|
# Both placeholders are Python versions like 2.7, 3.7, etc.
|
|
python.compatibility.inspection.advertiser.version.stale.python3.version.warning.message=\
|
|
Code compatibility inspection is configured for Python versions up to {0}.<br/>\
|
|
Would you like to enable it for Python {1}?<br/>\
|
|
<a href="#yes">Yes</a>\\ \\ <a href="#no">No</a>
|
|
|
|
python.install.framework.ensure.installed=Ensuring {0} is installed
|
|
python.install.framework.checking.is.installed=Checking if {0} is installed...
|
|
python.install.framework.installing=Installing {0}...
|
|
py.commandline.configure=Configures Python SDKs for the project
|
|
|
|
python.task.cannot.find.python.interpreter.for.selected.module=Cannot find Python interpreter for selected module
|
|
python.unknown.project.synchronizer.this.interpreter.type.does.not.support.remote.project.creation=This interpreter type does not support remote project creation
|
|
progress.text.connecting.to.console=Connecting to console...
|
|
progress.title.debugger.connection=Debugger connection
|
|
python.sdk.configuration.tab.title=Classes
|
|
python.console.rename.message=Enter new console name:
|
|
python.introduce.variable.refactoring.name=Introduce Variable
|
|
|
|
settings.completion.ml.python.display.name=Python
|
|
QFIX.pep8.edit.inspection.profile.setting=Edit inspection profile setting
|
|
|
|
python.remote.process.starter.can.t.run.remote.interpreter=Can't run remote python interpreter: {0}
|
|
python.remote.interpreter.can.t.create.project.this.type=Can't create project of this type on remote interpreter. Choose local interpreter.
|
|
dialog.message.error.on.python.side.exit.code.stderr.stdout=Error on python side. Exit code: {0}, err: {1} out: {2}
|
|
live.template.context.class=Class
|
|
|
|
python.buildout.parsing.error.section.name.expected=Section name expected.
|
|
python.buildout.parsing.error.key.expected=Key expected.
|
|
python.buildout.parsing.error.or.expected=: or = expected.
|
|
python.buildout.parsing.error.bracket.expected=] expected.
|
|
line.markers.popup.title.choose.super.method=Choose Super Method of {0}
|
|
line.markers.popup.title.choose.super.attribute=Choose Super Attribute of {0}
|
|
line.markers.popup.title.choose.subclass=Choose Subclass of {0}
|
|
line.markers.popup.title.choose.overriding.method=Choose Overriding Method of {0}
|
|
line.markers.tooltip.header.is.subclassed.by=Is subclassed by:
|
|
line.markers.tooltip.has.subclasses=Has subclasses
|
|
line.markers.tooltip.header.is.overridden.in=Is overridden in:
|
|
line.markers.tooltip.has.overridden.methods=Has overridden methods
|
|
line.markers.tooltip.overrides.method.in.class=Overrides method in {0}
|
|
line.markers.tooltip.overrides.attribute.in.class=Overrides attribute in {0}
|
|
python.find.module.usages.dialog.label.prefix.package=Package
|
|
python.find.module.usages.dialog.label.prefix.module=Module
|
|
goto.superclass.choose=Choose superclass
|
|
python.symbol.chooser.dialog.title=Choose Symbol
|
|
button.install.to.user.site.packages.directory=Install to user's site packages directory
|
|
framework.not.supported.for.the.selected.interpreter={0} is not supported for the selected interpreter
|
|
|
|
action.MarkNamespacePackageDirectory.text=Namespace package
|
|
python.unmark.as.namespace.package=Unmark as Namespace Package
|
|
python.unmark.as.python.namespace.package=Unmark as Python Namespace Package
|
|
python.namespace.package.folder=Namespace Package
|
|
python.python.namespace.package.folder=Python Namespace Package
|
|
python.namespace.packages.name=Namespace packages
|
|
python.namespace.packages.description=Namespace Package Folders
|
|
dialog.title.can.t.create.package=Create Package Error
|
|
command.name.create.new.package=Create New Package {0}
|
|
dialog.title.new.python.package=New Python Package
|
|
new.package.list.item.ordinary.package=Package
|
|
new.package.list.item.namespace.package=Namespace package
|