mirror of
https://gitflic.ru/project/openide/openide.git
synced 2025-12-16 22:51:17 +07:00
aa5eb8dc43
(cherry picked from commit fe2adaeabbf1862c2f51a93df14995264a251cca) IJ-MR-5221 GitOrigin-RevId: 08d0db849d31cdf7684a1b7a68d68072cc0d3686
1236 lines
72 KiB
Properties
1236 lines
72 KiB
Properties
### Quick fixes ###
|
|
QFIX.add.import.add.import=Add "''{0}''"
|
|
|
|
#PyImplementMethodsQuickFix
|
|
QFIX.NAME.implement.methods=Implement abstract methods
|
|
|
|
QFIX.NAME.change.signature=Change signature
|
|
QFIX.change.signature.of=Change the signature of {0}
|
|
|
|
QFIX.FAMILY.NAME.rename.element=Rename an element
|
|
QFIX.NAME.rename.element=Rename the element
|
|
|
|
QFIX.ignore.unresolved.reference=Ignore an unresolved reference
|
|
QFIX.ignore.unresolved.reference.0=Ignore an unresolved reference ''{0}''
|
|
QFIX.mark.all.unresolved.attributes.of.0.as.ignored=Mark all unresolved attributes of ''{0}'' as ignored
|
|
QFIX.fill.paragraph=Fill the paragraph
|
|
QFIX.remove.trailing.blank.lines=Remove trailing blank lines
|
|
QFIX.generating.skeletons.for.binary.module=Generating skeletons for a binary module
|
|
QFIX.generate.binary.stubs=Generate binary stubs
|
|
QFIX.reformat.file=Reformat the 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}'' is obscured by local definitions
|
|
CONFLICT.name.obscured.cannot.convert=Name ''{0}'' is obscured. Cannot convert.
|
|
CONFLICT.occurrence.pl=occurrences
|
|
|
|
##########################################################################################################################
|
|
# Unwrap
|
|
##########################################################################################################################
|
|
unwrap.if=Unwrap if\u2026
|
|
unwrap.while=Unwrap while\u2026
|
|
unwrap.for=Unwrap for\u2026
|
|
unwrap.with=Unwrap with\u2026
|
|
unwrap.try=Unwrap try\u2026
|
|
unwrap.else=Unwrap else\u2026
|
|
unwrap.elif=Unwrap elif\u2026
|
|
remove.else=Remove else\u2026
|
|
remove.elif=Remove elif\u2026
|
|
|
|
INSP.GROUP.python=Python
|
|
|
|
# Refactoring
|
|
refactoring.will.not.be.accessible=The 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 the selected element(s)
|
|
|
|
# introduce variable
|
|
refactoring.introduce.variable.dialog.title=Extract Variable
|
|
refactoring.introduce.variable.scope.error=The name clashes with an existing variable or parameter
|
|
|
|
# introduce constant
|
|
refactoring.introduce.constant.dialog.title=Extract Constant
|
|
refactoring.introduce.constant.scope.error=The name is already declared in the scope
|
|
refactoring.introduce.constant.cannot.extract.selected.expression=Selected expression cannot be extracted into a constant
|
|
|
|
# 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 the function {0}
|
|
refactoring.inline.method=Inline the 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=The function {0} is used as a decorator and cannot be inlined. The function definition will not be removed
|
|
refactoring.inline.function.is.reference=The function {0} is used as a reference and cannot be inlined. The function definition will not be removed
|
|
refactoring.inline.function.uses.unpacking=The function {0} uses argument unpacking and cannot be inlined. The 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 a function from the 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 nonlocal 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 the selected element(s)
|
|
refactoring.extract.method.error.name.clash=The method name clashes with an already existing name
|
|
refactoring.extract.method.error.returns=Cannot extract a method with return instructions inside a code fragment
|
|
refactoring.extract.method.error.local.variable.modifications=Cannot perform refactoring from expression with local variable modifications inside a code fragment
|
|
refactoring.extract.method.error.local.variable.modifications.and.returns=Cannot perform refactoring from expression with local variables modifications and return instructions inside a code fragment
|
|
refactoring.extract.method.error.empty.fragment=Cannot perform refactoring from an empty code fragment
|
|
|
|
refactoring.extract.method.error.class.level=Cannot perform refactoring at a class level
|
|
|
|
# extract superclass
|
|
refactoring.extract.super.target.path.outside.roots=The target directory is outside the project. It 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. It 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=The destination file already contains a class named ''{0}''
|
|
refactoring.move.error.destination.file.contains.function=The destination file already contains a function named ''{0}''
|
|
refactoring.move.error.destination.file.contains.global.variable=The destination file already contains a global variable named ''{0}''
|
|
refactoring.move.error.cannot.use.module.name=Cannot use a 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 the function {0}
|
|
refactoring.move.module.members.dialog.description.variable=Move the global variable {0}
|
|
refactoring.move.module.members.dialog.description.selection=Move the 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 the 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 a function with nonlocal writes
|
|
refactoring.make.function.top.level.error.self.reads=Cannot move a function that contains usages of the "self" parameter from the outer scope
|
|
refactoring.make.function.top.level.error.outer.scope.reads=Cannon move a method that references names from the outer scope
|
|
refactoring.make.function.top.level.error.private.attributes=Cannot move a method that references private instance attributes
|
|
refactoring.make.function.top.level.error.attribute.writes=Cannot move a method that writes to instance attributes
|
|
refactoring.make.function.top.level.error.method.calls=Cannot move a method that calls other methods of the same class
|
|
refactoring.make.function.top.level.error.special.usage.of.self=Cannot move a method that contains special usages of the "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 the 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 the class {1}\noverrides method of the 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=The caret is positioned on lambda call
|
|
refactoring.change.signature.error.tuple.parameters=The function contains tuple parameters
|
|
refactoring.change.signature.error.not.under.source.root=The function is not under the source root
|
|
refactoring.change.signature.suggested.callSite.value=The value of a call site
|
|
refactoring.change.signature.suggested.callSite.value.optional=An 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 the field: not in the class
|
|
refactoring.rename.containing.file.with.the.following.name.to=Rename a containing file with the following name to:
|
|
refactoring.rename.containing.file.title=Rename Containing File
|
|
refactoring.rename.containing.file=Rename a containing file
|
|
refactoring.rename.containing.file.entity.name=Containing File
|
|
refactoring.rename.parameter.in.hierarchy.to=Rename a parameter in hierarchy to:
|
|
refactoring.rename.parameter.entity.name=Parameter
|
|
refactoring.rename.parameters.title=Rename Parameters
|
|
refactoring.rename.parameters.in.hierarchy=Rename parameters in the hierarchy
|
|
refactoring.rename=Rename
|
|
refactoring.rename.not.valid.identifier=The name ''{0}'' is not a valid Python identifier. Cannot update an 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
|
|
|
|
python.run.select.script=Select Script
|
|
python.run.configuration=Python run configuration
|
|
python.run.python=Python
|
|
|
|
python.testing.target.not.provided=The target is not provided
|
|
python.testing.provide.qualified.name=Provide a qualified name of a function, class or module
|
|
python.testing.pattern.can.only.be.used=Pattern can only be used to match files in a folder. Can't use pattern for a file.
|
|
python.testing.cant.resolve=Can''t resolve {0}. Try to remove the configuration and generate it again
|
|
python.testing.cant.find.where.declared=Can''t find file where {0} declared. Make sure it is in the project root
|
|
python.testing.cant.get.importable.name=Can''t get an 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, then right-click to create a new one.
|
|
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.config.keywords=Keywords
|
|
runcfg.pytest.config.parameters=Parameters
|
|
|
|
group.advanced.settings.python=Python
|
|
advanced.setting.python.pytest.swapdiff=Pytest: swap actual/expected in diff
|
|
advanced.setting.python.pytest.show_summary=Pytest: do not add "--no-header --no-summary -q"
|
|
|
|
|
|
runcfg.autodetect.display_name=Autodetect
|
|
|
|
### 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 a script name
|
|
runcfg.unittest.no_module_name=Please specify a qualified name of the module
|
|
runcfg.unittest.no_class_name=Please specify a class name
|
|
runcfg.unittest.no_method_name=Please specify a method name
|
|
runcfg.unittest.no_folder_name=Please specify a 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=An 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 the selected interpreter
|
|
|
|
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
|
|
python.console.toolbar.action.available.non.interactive=The action is not available for non-interactive shell
|
|
|
|
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=Teh 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
|
|
filetype.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\u2026
|
|
python.sdk.updater.notifications.group.title=Python SDK Updater
|
|
python.sdk.updating.skeletons=Updating skeletons\u2026
|
|
python.sdk.unpacking.pre.generated.skeletons=Unpacking pre-generated skeletons\u2026
|
|
python.sdk.popup.interpreter.settings=Interpreter Settings\u2026
|
|
python.sdk.popup.add.interpreter=Add Interpreter\u2026
|
|
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.new.project.environment=Environment:
|
|
python.sdk.new.project.environment.type=Environment type:
|
|
|
|
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 a 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.
|
|
|
|
python.sdk.interpreter.executable.path.title=Python Interpreter Executable Path
|
|
python.sdk.action.add.new.interpreter.text=Add New Interpreter
|
|
|
|
python.sdk.action.add.local.interpreter.text=Add Local Interpreter...
|
|
python.sdk.action.add.interpreter.based.on.target.text=On {0}...
|
|
|
|
# SDK / skeletons
|
|
sdk.some.skeletons.failed=Some skeletons failed to generate
|
|
sdk.gen.cleaning.up=Cleaning up skeletons\u2026
|
|
sdk.gen.launching.generator=Launching skeleton generator\u2026
|
|
sdk.gen.reloading=Reloading generated skeletons\u2026
|
|
sdk.gen.unpacking.prebuilt=Unpacking prebuilt skeletons\u2026
|
|
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\u2026
|
|
sdk.updating.interpreter.version=Updating interpreter version\u2026
|
|
|
|
# Active SDK configurable and related dialogs
|
|
active.sdk.dialog.show.all.item=Show All\u2026
|
|
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
|
|
active.sdk.dialog.link.add.interpreter.text=Add Interpreter
|
|
|
|
sdk.details.step.add=Add\u2026
|
|
sdk.details.step.show.all=Show All\u2026
|
|
|
|
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=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.dialog.interpreter.label=Interpreter:
|
|
sdk.create.venv.dialog.location.label=Location:
|
|
sdk.create.venv.dialog.base.interpreter.label=Base interpreter:
|
|
sdk.create.venv.conda.dialog.label.interpreter=Interpreter:
|
|
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 the remote server. Make sure you have permissions.
|
|
remote.interpreter.accessing.remote.interpreter.progress.title=Accessing Remote Interpreter
|
|
|
|
# CommandLine
|
|
commandLine.inspection.name=Incorrect CLI syntax
|
|
commandLine.inspection.badCommand=Bad or unknown command. Ensure this command exists.
|
|
commandLine.inspection.badOption=Bad or unknown option. Ensure this option exists.
|
|
commandLine.inspection.badArgument=Argument cannot have this value. Use autocompletion to check the 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.parameters=Method declaration parameters
|
|
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\u2026
|
|
action.PySyncPythonRequirements.text=Sync Python Requirements\u2026
|
|
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.PyConsoleOptionsConfigurable.display.name=Console
|
|
configurable.PyConsoleOptionsConfigurable.child.display.name=Python Console
|
|
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\u2026
|
|
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 the selected Python interpreter
|
|
qt.run.designer.error=Error
|
|
qt.ui.designer.form.filetype.description=Qt UI Designer form
|
|
qt.ui.designer.form.filetype.display.name=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, 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
|
|
|
|
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=Choose the 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.getting.table.data=Table Data
|
|
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\u2026
|
|
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\u2026
|
|
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"
|
|
console.table.failed.to.load=Failed to load:
|
|
|
|
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 a 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 the 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\u2026
|
|
debugger.waiting.to.finish=Waiting for Python Console process to finish\u2026
|
|
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=The port number is out of boundaries
|
|
|
|
debugger.dataviewer.action.export.name=Export\u2026
|
|
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\u2026
|
|
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\u2026
|
|
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=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.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 an 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 is 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\u2026
|
|
python.packaging.installing.packages=Installing packages\u2026
|
|
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\u2026
|
|
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=\
|
|
You are attempting to uninstall {0} package which is required for {1} {2, 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\u2026
|
|
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=Installing 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=Uninstalling packages failed
|
|
python.packaging.progress.text.installing.specific.package=Installing package ''{0}''\u2026
|
|
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.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 auto-import tooltip
|
|
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 the 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.tox.configuration.arguments=Arguments:
|
|
form.tox.configuration.environments.to.run=Environments to run:
|
|
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 cannot be generated
|
|
error.in.project.generation=Error in Project Generation
|
|
|
|
sdk.has.been.configured.as.the.project.interpreter={0} has been configured as a 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
|
|
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 an 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.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
|
|
toolwindow.stripe.Jupyter_Variables=Jupyter Variables
|
|
|
|
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.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\u2026
|
|
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 the 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.pep8.ignore.errors.label=Ignored errors:
|
|
INSP.settings.bdd.behave.specific=Incorrect BDD Behave-specific definitions
|
|
INSP.settings.bdd.step.definition.arguments=Incorrect arguments in step definition functions
|
|
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\u2026
|
|
python.install.framework.installing=Installing {0}\u2026
|
|
py.commandline.configure=Configures Python SDKs for the project
|
|
|
|
python.task.cannot.find.python.interpreter.for.selected.module=Cannot find a 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\u2026
|
|
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=Cannot run the remote Python interpreter: {0}
|
|
python.remote.interpreter.can.t.create.project.this.type=Cannot create a project of this type on a 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
|
|
live.template.context.top.level=Top-level
|
|
|
|
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
|
|
|
|
# Python Packages toolwindow
|
|
python.toolwindow.packages.installed.label=Installed
|
|
python.toolwindow.packages.custom.repo.searched={0} ({1} found)
|
|
python.toolwindow.packages.pypi.repo.label=PyPI repository
|
|
python.toolwindow.packages.documentation.link=Documentation
|
|
python.toolwindow.packages.no.interpreter.text=Select an interpreter to see the installed packages
|
|
python.toolwindow.packages.latest.version.label=latest
|
|
python.toolwindow.packages.install.button=Install
|
|
python.toolwindow.packages.delete.package=Delete Package
|
|
python.toolwindow.packages.search.text.placeholder=Search for more packages
|
|
python.toolwindow.packages.description.panel.placeholder=Select a package to view documentation
|
|
python.toolwindow.packages.request.failed=<html><head></head><body><p class="empty_description">Request failed.</p></body></html>
|
|
python.toolwindow.packages.no.description.placeholder=<html><head></head><body><p class="empty_description">Package author did not provide a description.</p></body></html>
|
|
python.toolwindow.packages.remote.interpreter.placeholder=<html><head></head><body><p class="empty_description">Local interpreter is required to view package documentation.</p></body></html>
|
|
python.toolwindow.packages.collecting.packages.task.title=Collecting packages
|
|
python.toolwindow.packages.rst.parsing.failed=Failed to parse the description
|
|
python.toolwindow.packages.no.documentation=No documentation found in current repository
|
|
python.toolwindow.packages.manage.repositories.action=Manage repositories
|
|
python.toolwindow.packages.reload.repositories.action=Reload all repositories
|
|
python.toolwindow.packages.add.package.action=Add Package
|
|
python.toolwindow.packages.add.package.from.vcs=From Version Control
|
|
python.toolwindow.packages.add.package.from.disc=From Disk
|
|
python.toolwindow.packages.add.package.as.editable=Install as editable (-e)
|
|
python.toolwindow.packages.add.package.vcs.git=Git
|
|
python.toolwindow.packages.add.package.vcs.svn=Subversion
|
|
python.toolwindow.packages.add.package.vcs.hg=Mercurial
|
|
python.toolwindow.packages.add.package.vcs.bzr=Bazaar
|
|
python.toolwindow.packages.add.package.path=Path
|
|
python.toolwindow.packages.add.package.path.selector=Select File Or Directory
|
|
python.toolwindow.packages.add.package.dialog.title=Install Package
|
|
python.toolwindow.packages.load.more=\u2026 {0} more items. Double click to show more.
|
|
python.toolwindow.packages.load.more.start=\u2026
|
|
|
|
vcs.activate.virtualenv.checkbox.text=Activate virtualenv for hooks
|
|
|
|
notification.action.edit.settings=Edit settings
|
|
python.template.language.none=None
|
|
|
|
|
|
|
|
enter.path.dialog.title=Enter Path
|
|
path.label=Path:
|
|
path.must.not.be.empty.error.message=Path must not be empty
|
|
path.must.be.absolute.error.message=Path must be absolute
|
|
path.ends.with.whitespace.warning.message=Path ends with the whitespace
|
|
|
|
# Python run target language
|
|
python.language.configure.label=Python Configuration
|
|
python.language.run.label=Run Python application
|
|
|
|
configurable.name.python.language=Python Language
|
|
|
|
# Python Command Queue
|
|
python.console.command.queue.add.title={0} Command Queue
|
|
python.console.command.queue.show.action.text=Show Command Queue
|
|
python.console.command.queue.show.action.description=Shows window with CommandQueue
|
|
python.console.command.queue.got.it.tooltip.id=python.console.command.queue.show
|
|
python.console.command.queue.got.it.tooltip.title=Console Command Queue
|
|
python.console.command.queue.got.it.tooltip.text=Commands queued in line for execution are listed in the Command Queue popup
|