openide/python/pluginResources/messages/PyBundle.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 unresolved references
QFIX.ignore.unresolved.reference.0=Ignore unresolved references ''{0}''
QFIX.mark.all.unresolved.attributes.of.0.as.ignored=Ignore all unresolved attributes of ''{0}''
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 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

# 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.selection=Cannot perform refactoring using the selected element(s)
refactoring.move.module.members.error.selection.empty=No members selected

# 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.run.anything.file.provider=Run Python file
python.run.anything.pip.provider=Run pip command
python.run.anything.conda.provider=Run conda command

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.parameters.group.name=Pytest
runcfg.pytest.config.keywords=Keywords
runcfg.pytest.config.keywords.hint=Keyword filters
runcfg.pytest.config.keywords.action.hint=Filter tests by keyword expressions

runcfg.pytest.config.parameters=Parameters
runcfg.pytest.config.parameters.label=Pytest parameters
runcfg.pytest.config.parameters.hint=Custom tests parameters
runcfg.pytest.config.parameters.action.hint=Custom test parameters

runcfg.pytest.config.additional.arguments=Additional arguments
runcfg.pytest.config.additional.arguments.hint=Additional pytest options
runcfg.pytest.config.additional.arguments.action.hint=Specify extra pytest command-line options

group.advanced.settings.python=Python
advanced.setting.python.pytest.swapdiff=Swap the order of actual and expected assertions in Pytest
advanced.setting.python.pytest.show_summary=Pytest: do not add "--no-header --no-summary -q"
advanced.setting.python.code.vision.usages.limit=Code Vision: maximum number of usages to search
advanced.setting.python.debugger.attach.timeout=Debugger: Attach to Process connection timeout


runcfg.autodetect.display_name=Autodetect
runcfg.autodetect.parameters.group.name=Python test

### 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}
runcfg.test.unknown.group=Unknown

### 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.selected=An invalid Python interpreter selected ''{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
runcfg.error.message.python.interpreter.is.invalid.configure=Please <a href="#">reconfigure</a> Python interpreter

# 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.cannot.evaluate.sdk.version.error.message=Can't evaluate sdk 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 interpreter update failed
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.package.progress.title=Downloading package from {0}
python.sdk.select.conda.path.title=Select Path to Conda Executable
python.sdk.conda.no.env.selected.error=No Conda enviroment selected
python.sdk.conda.no.base.env.error=No base Conda envrionment available
python.sdk.conda.problem.running=Problem running conda
python.sdk.conda.problem.env.empty.invalid=Environment name is empty or invalid
python.sdk.conda.problem.env.name.used=This name is used already. Please, choose another one.
python.sdk.conda.getting.list.envs=Getting list of conda envs
python.sdk.conda.no.exec=Conda executable is not found
python.sdk.conda.cant.create.title=Conda can't create new environment
python.sdk.conda.cant.create.body=The error is: ''{0}''
python.sdk.conda.env=Environment
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.new.error.no.absolute=Path must be absolute

# Poetry package manager and SDK
python.sdk.poetry.executable.not.found=Poetry executable is not found
python.sdk.poetry.executable=Poetry executable:
python.sdk.poetry.select.executable.title=Select Path to Poetry Executable
python.sdk.poetry.associated.project=Associated project:
python.sdk.poetry.associated.module=Associated module:
python.sdk.poetry.execution.exception.no.project.message=Cannot find the project associated with this Poetry environment
python.sdk.poetry.execution.exception.no.poetry.message=Cannot find Poetry
python.sdk.poetry.quickfix.fix.pipenv.name=Fix Poetry interpreter
python.sdk.poetry.quickfix.use.pipenv.name=Use Poetry interpreter
python.sdk.poetry.pip.file.lock.not.found=poetry.lock is not found
python.sdk.poetry.pip.file.lock.out.of.date=poetry.lock is out of date
python.sdk.poetry.pip.file.notification.content=Run <a href='#lock'>poetry lock</a> or <a href='#update'>poetry update</a>
python.sdk.poetry.pip.file.notification.content.without.updating=Run <a href='#lock'>poetry lock</a>, <a href='#noupdate'>poetry lock --no-update</a> or <a href='#update'>poetry update</a>
python.sdk.poetry.pip.file.notification.locking=Locking poetry.lock
python.sdk.poetry.pip.file.notification.locking.without.updating=Locking poetry.lock without updating
python.sdk.poetry.pip.file.notification.updating=Updating Poetry environment
python.sdk.poetry.pip.file.watcher=pyproject.toml Watcher
python.sdk.dialog.title.setting.up.poetry.environment=Setting up poetry environment
python.sdk.intention.family.name.install.requirements.from.poetry.lock=Install requirements from poetry.lock
python.sdk.inspection.message.version.outdated.latest=''{0}'' version {1} is outdated (latest: {2})
python.sdk.dialog.message.cannot.find.script.file.please.run.poetry.install.before.executing.scripts=Cannot find a script file\nPlease run 'poetry install' before executing scripts
python.sdk.dialog.title.poetry.scripts=Poetry Scripts
python.sdk.poetry.action.run.script.text=Run ''{0}''
python.sdk.inspection.message.poetry.interpreter.associated.with.another.project=Poetry interpreter is associated with another {0}: {1}
python.sdk.inspection.message.poetry.interpreter.not.associated.with.any.project=Poetry interpreter is not associated with any {0}
python.sdk.dialog.message.creating.virtual.environments.based.on.poetry.environments.not.supported=Creating virtual environments based on Poetry environments is not supported
python.sdk.poetry.environment.panel.title=Poetry Environment
python.sdk.poetry.install.packages.from.toml.checkbox.text=Install packages from pyproject.toml
python.sdk.poetry.dialog.message.poetry.interpreter.has.been.already.added=Poetry interpreter has been already added, select ''{0}''
python.sdk.poetry.dialog.add.new.environment.in.project.checkbox=Create an in-project environment

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.installation.failed.title={0} Installation Failed
python.sdk.download.failed.title={0} Download Failed
python.sdk.installation.cancelled.message=Cancelled by the user
python.sdk.installation.notification.group=Python interpreter installation
python.sdk.installation.balloon.error.message=<b>Python installation interrupted</b><br/>Download Python manually from python.org, install it and configure the project interpreter.
python.sdk.installation.balloon.error.action=See the documentation
python.sdk.download.failed.message=Connection timeout.\nPlease check the internet access and try again
python.sdk.directory.not.found=Directory {0} not found
python.sdk.failed.to.create.interpreter.title=Failed to create interpreter
python.sdk.failed.to.create.interpreter.with.error.title=Failed to create interpreter. Exception:\n{0}
python.sdk.can.t.obtain.python.version=Can't obtain python version
python.sdk.empty.version.string=Python interpreter returned the empty output as a version string
python.sdk.non.zero.exit.code=Python interpreter process exited with a non-zero exit code {0}
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 {1} 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.executable.not.found.option.install.with.cldt=Click {0} to install Python with the Command-Line Developer Tools: {1}
python.sdk.executable.not.found.option.install.or.brew=Install Python manually from python.org or via Homebrew
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.admin.permissions.needed.consider.creating.venv.content=<strong>Note:</strong> You'll need admin permissions to install packages for this interpreter. Consider creating a per-project virtual environment instead.
python.sdk.try.to.install.manually=Try to install {0} manually.
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\u2026
python.sdk.action.add.interpreter.based.on.target.text=On {0}\u2026

python.cldt.checking=Checking for Command-Line Developer Tools installation
python.cldt.required=Selected python requires Command-Line Developer Tools: {0}
python.cldt.installing.suggestion=Install Python with the Command-Line Developer Tools
python.cldt.installing.title=Waiting for Python Installation and Interpreter Setup
python.cldt.installing.indicator=macOS is installing Command-Line Developer Tools
python.cldt.installing.skip=Skip this step to configure an interpreter later

# 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.dependencies.filter=TXT|PY files

sdk.create.venv.dialog.label.inherit.global.site.packages=Inherit global site-packages
sdk.create.venv.environment.label=Environment:
sdk.create.venv.existing.option.label=Existing
sdk.create.venv.new.option.label=New
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:


sdk.create.interpreter.type=Interpreter type:
sdk.create.type.project.venv=Project venv
sdk.create.type.base.conda=Base conda
sdk.create.type.custom=Custom environment
sdk.create.python.version=Python version:
sdk.create.conda.executable.path=Path to conda:
sdk.create.conda.missing.text=No conda executable found.
sdk.create.conda.install.fix=Install Miniconda
sdk.create.simple.venv.hint=Python virtual environment will be created in the project root: {0}
sdk.create.simple.conda.hint=To create a new conda environment or choose an existing one, proceed with Custom environment
sdk.create.custom.develop.on=Develop on:
sdk.create.custom.env.creation.type=Environment:
sdk.create.custom.generate.new=Generate new
sdk.create.custom.select.existing=Select existing
sdk.create.custom.type=Type:
sdk.create.custom.base.python=Base python:
sdk.create.custom.location=Location:
sdk.create.custom.venv.missing.text=No {0} executable found.
sdk.create.custom.inherit.packages=Inherit packages from base interpreter
sdk.create.custom.make.available=Make available to all projects
sdk.create.custom.python.path=Python path:
sdk.create.custom.python.browse.tooltip="Select Python executable"
sdk.create.custom.venv.location.browse.title=Select virtualenv location
sdk.create.custom.conda.browse.title=Select Conda Executable
sdk.create.custom.conda.env.name=Name:
sdk.create.custom.conda.create.progress=Creating conda interpreter
sdk.create.custom.conda.select.progress=Selecting conda interpreter
sdk.create.custom.conda.refresh.envs=Reload environments
sdk.create.custom.venv.executable.path=Path to {0}:
sdk.create.custom.select.executable.link=Select path
sdk.create.custom.venv.environment.exists=Environment "{0}" already exists in the specified folder
sdk.create.custom.venv.folder.not.empty=The specified folder already exists
sdk.create.custom.venv.use.different.venv.link=Use {0}
sdk.create.custom.venv.select.existing.link=Select existing interpreter
sdk.create.not.executable.empty.error=Specify path to executable
sdk.create.not.executable.does.not.exist.error=Executable does not exist
sdk.create.executable.directory.error=Path can't be a directory
sdk.create.tooltip.browse=Browse\u2026
sdk.create.custom.venv.install.fix.title=Install {0} {1}
sdk.create.custom.venv.run.error.message= Error Running {0}
sdk.create.custom.venv.progress.title.detect.executable=Detect executable

sdk.create.targets.local=Local Machine
sdk.create.custom.virtualenv=Virtualenv
sdk.create.custom.conda=Conda
sdk.create.custom.pipenv=Pipenv
sdk.create.custom.poetry=Poetry
sdk.create.custom.python=Python

sdk.rendering.detected.grey.text=detected in the system
sdk.rendering.installable.grey.text=download and install

new.project.name=Name:
new.project.location=Location:
new.project.location.hint=Project will be created in: {0}
new.project.git=Create Git repository
new.project.welcome=Create a welcome script


# 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
remote.interpreter.feature.is.not.available=Remote interpreter feature is not available

# What to display of user entered junk
commandLine.commandNotFound={0}: command not found
commandLine.directoryCantBeAccessed={0}: Directory couldn't be found or doesn't contain virtual env

# Window with actions
# "X" button title
windowWithActions.closeWindow=Close window
# "Stop" button title
windowWithActions.stopProcess=Stop currently running process

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
smartKeys.wrap.in.parentheses.instead.of.backslash=Use parentheses instead of backslashes for breaking lines

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.XDebugger.CopyValue.text=Copy Value
action.XDebugger.CopyValue.description=Copy value of selected node to clipboard
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
group.PyDebugger.ViewAsGroup.text=View as
action.PyDebugger.ViewArray.text=View as Array
action.PyDebugger.CustomizeDataView.text=Customize Data View
action.PythonGenerateDictionaries.text=Generate Python Spellchecker Dictionaries
group.PyPackagingMenu.text=Packaging
action.CollapsePythonTypeAnnotations.text=Collapse Python Type Annotations
action.CollapsePythonTypeAnnotations.description=Collapse python type annotations
action.ExpandPythonTypeAnnotations.text=Expand Python Type Annotations
action.ExpandPythonTypeAnnotations.description=Expand python type annotations
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.PyUserTypeRenderersConfigurable.display.name=Python Type Renderers
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

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 package recommended
code.insight.create.test=Create test
code.insight.select.target.directory=Select target directory
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.setting.user.type.renderers=User Type Renderers
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

run.debug.shadowing.name.import.error.title=Looks like {0} shadows standard library file name. This may cause unexpected Run/Debug action behavior
run.debug.shadowing.name.import.error.rename=Rename {0}
run.debug.shadowing.name.import.error.open.file=Show {0}

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.reach.view.suggestion=Rich table viewer could be enabled
debugger.data.view.failed.to.evaluate.expression=Failed to evaluate the expression {0}
debugger.data.view.numpy.is.not.available=NumPy is not available. Install the module for proper data display.
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.variables.view.quoting.policy=Variables Quoting
debugger.variables.view.quoting.single.text=Single quotes
debugger.variables.view.quoting.single.description=Enclose values in single quotes
debugger.variables.view.quoting.double.text=Double quotes
debugger.variables.view.quoting.double.description=Enclose values in double quotes
debugger.variables.view.quoting.without.text=Without quotes
debugger.variables.view.quoting.without.description=Copy values without quotes
debugger.exception.breakpoint.select.exception.class=Select Exception Class
debugger.watch.show.return.values=Show Return Values
debugger.data.view.title=Data View
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.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.gcc=Command 'gcc' failed with exit status 1
debugger.cython.extension.gcc.failed=\n\nInstall a C compiler in order to build Cython extensions for the debugger.\n
debugger.cython.extension.python.h=Python.h: No such file or directory
debugger.cython.extension.python.h.not.found=\n\nUse your package manager to install header files and static libraries for Python dev system-wide.\n\nTry command:\n {0}\n
debugger.cython.extension.install.python.command=<code>sudo apt-get install python{0}-dev</code>
debugger.cython.extension.gcc.not.found=x86_64-linux-gnu-gcc
debugger.cython.extension.gcc.not.found.suggestion=\n\nUse your package manager to install the missing <code>gcc</code>.\n\nTry command:\n<code>sudo apt install gcc</code>
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
debugger.progress.title.stackframe.processing=StackFrame processing

python.local.attach.group.name=Python

pydev.console.runner.settings=Settings
pydev.console.runner.output.actions=Output Actions
pydev.console.runner.copy.console.output.text=Copy Console Output
pydev.console.runner.copy.console.output.description=Copy console output to clipboard

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.colors.local.variables=Local variables
python.colors.type.parameters=Type parameters

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.failed.to.install.packaging.tools.title=Failed to Install Python Packaging Tools
python.packaging.install.packaging.tools=Install packaging tools
python.packaging.create.setup.package.name=Package name
python.packaging.create.setup.version=Version
python.packaging.create.setup.url=URL
python.packaging.create.setup.license=License
python.packaging.create.setup.author=Author
python.packaging.create.setup.author.email=Author Email
python.packaging.create.setup.description=Description

# 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 that 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.packaging.dialog.title.install.package.confirmation=Confirm Package Installation
python.packaging.dialog.message.install.package.confirmation=\
  You are installing the package <b>{0}</b>. \
  Make sure that the package name is correct.\n\n\
  Do you want to continue?

python.unresolved.reference.inspection.install.package=Install package {0}
python.unresolved.reference.inspection.install.all=Install all missing packages

# UI forms

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.options.use.command.queue=Command queue for Python Console
form.console.options.code.completion=Code completion
form.console.options.static.code.completion=Static
form.console.options.runtime.code.completion=Runtime
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.run.debugger.in.server.mode=Run debugger in server mode
form.debugger.debugger.port=Debugger port:
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.debugger.variables.view.user.type.renderers.name=Renderer name:
form.debugger.variables.view.user.type.renderers.append.default.children=Append default children
form.debugger.variables.view.user.type.renderers.apply.renderer.to.objects.of.type=Apply renderer to objects of type (fully qualified name):
form.debugger.variables.view.user.type.renderers.when.rendering.node=When rendering a node:
form.debugger.variables.view.user.type.renderers.when.expanding.node=When expanding a node:
form.debugger.variables.view.user.type.renderers.use.default.renderer=Use default renderer
form.debugger.variables.view.user.type.renderers.use.following.expression=Use the following expression:
form.debugger.variables.view.user.type.renderers.use.list.of.expressions=Use list of expressions:
form.debugger.variables.view.user.type.renderers.variable.name=Use 'self' as a variable name
form.debugger.variables.view.user.type.renderers.class.not.found=Class not found
form.debugger.variables.view.user.type.renderers.unnamed=Unnamed
form.debugger.variables.view.user.type.renderers.renderer=renderer
form.debugger.variables.view.user.type.renderers.no.renderers=No renderers
form.debugger.variables.view.user.type.renderers.configure.renderer=Configure Renderer
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.run.configuration.fragments.chooser.hint=Run Python script or module
python.run.configuration.fragments.script.path.hint=Path to a Python script
python.run.configuration.fragments.module.name.hint=Name of a module
python.run.configuration.fragments.custom.field.hint=Custom run target
python.run.configuration.fragments.project=Project
python.run.configuration.fragments.project.hint=Select a project
python.run.configuration.fragments.interpreter.field=Python interpreter
python.run.configuration.fragments.interpreter.options=Interpreter options
python.run.configuration.fragments.interpreter.options.hint=Python interpreter options
python.run.configuration.fragments.interpreter.options.placeholder=Interpreter options
python.run.configuration.fragments.script.parameters=Parameters
python.run.configuration.fragments.script.parameters.hint=Script parameters
python.run.configuration.fragments.run.with.python.console=Run with Python Console
python.run.configuration.fragments.run.with.python.console.hint=Execute run configuration in Python Console
python.run.configuration.fragments.emulate.terminal=Emulate terminal in output console
python.run.configuration.fragments.emulate.terminal.hint=Emulate terminal in output console
python.run.configuration.fragments.content.roots=Add content roots to PYTHONPATH
python.run.configuration.fragments.content.roots.hint=Add content roots to PYTHONPATH
python.run.configuration.fragments.source.roots=Add source roots to PYTHONPATH
python.run.configuration.fragments.source.roots.hint=Add source roots to PYTHONPATH
python.run.configuration.fragments.python.group=Python
python.run.configuration.fragments.plugin.sdk.chooser.hint=Python interpreter
python.run.configuration.fragments.plugin.sdk.of.module=Use SDK of module
python.run.configuration.fragments.plugin.sdk.of.module.hint=Select module
python.run.configuration.fragments.plugin.specified.interpreter=Use specified interpreter
python.run.configuration.fragments.plugin.specified.interpreter.hint=Select 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

python.interpreter.local.configurable.remove.association=Remove association

pure.python.project=Pure Python
project.cannot.be.generated=Project cannot be generated
error.in.project.generation=Error in Project Generation

sdk.venv.process=Creating virtual env
sdk.venv.error=Error creating virtual env: {0}
sdk.has.been.configured.as.the.project.interpreter={0} has been configured as a project interpreter
sdk.has.been.configured.notification.name=Python interpreter configured
configuring.interpreters.link=Configure Interpreters
looking.for.inner.venvs=Looking for inner virtual environments
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

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.path.to.conda.field=Conda Executable
python.add.sdk.panel.load.envs=Load Environments
python.add.sdk.panel.wait=Please wait\u2026
python.add.sdk.panel.conda.use.existing=Use existing environment
python.add.sdk.panel.conda.create.new=Create new environment
python.add.sdk.panel.conda.env.name=Environment name:
python.add.sdk.python.version=Python version:
python.add.sdk.error=Error
python.add.sdk.conda.detecting=Detecting conda\u2026
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.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
toolwindow.stripe.Python_Packages=Python Packages

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.type.annotations=Type annotations
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.template.select.file.type=Select File Type

action.PyExecuteCellAction.text=Execute Cell in Console
action.PyExecuteCellActionWithMove.text=Execute Cell in Console

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 recommended
python.compatibility.inspection.advertiser.notifications.title=Python versions compatibility
INSP.poetry.package.versions.display.name=Poetry package versions

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>\\&nbsp;\\&nbsp;<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>\\&nbsp;\\&nbsp;<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>\\&nbsp;\\&nbsp;<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

postfix.template.provider.name=Python
postfix.template.condition.iterable.name=iterable
postfix.template.condition.list.name=list
postfix.template.condition.set.name=set
postfix.template.condition.tuple.name=tuple
postfix.template.condition.dict.name=dict
postfix.template.condition.builtin.len.applicable.name=builtin len applicable
postfix.template.condition.non.none.name=non None
postfix.template.condition.exception.name=exception
postfix.template.condition.number.name=number
postfix.template.condition.boolean.name=boolean
postfix.template.condition.string.name=string

settings.postfix.choose.class.action.name=Choose Class\u2026
settings.postfix.choose.class.prompt.text=Choose class
settings.postfix.enter.class.action.name=Enter Class Name\u2026
settings.postfix.enter.class.dialog.name=Choose Class
settings.postfix.enter.fully.qualified.class.name=Enter fully qualified class name

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

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 packaging
python.packaging.repository.manage.dialog.name=Python Package Repositories
python.packaging.repository.form.url=Repository URL:
python.packaging.repository.form.authorization=Authorization:
python.packaging.repository.form.authorization.none=None
python.packaging.repository.form.authorization.basic=Basic HTTP
python.packaging.repository.form.login=Login:
python.packaging.repository.form.password=Password:
python.packaging.repository.form.default.name=Package Repository
python.packaging.loading.packages.progress.text=Loading packages\u2026
notification.group.packaging=Python packaging
notification.group.packaging.toolwindow=Python Packages
python.packaging.install.progress=Installing package {0}
python.packaging.uninstall.progress=Uninstalling package {0}
python.packaging.update.progress=Updating package {0}
python.packaging.list.progress=Reading installed python packages
python.packaging.operation.failed.title=Packaging Operation Failed
python.packaging.could.not.parse.response=<html><head></head><body><p class="empty_description">Could not parse the response for the package {0} from repository {1}</p></body></html>
python.packaging.notification.installed=Package {0} installed
python.packaging.notification.deleted=Package {0} deleted
python.packaging.notification.update.failed=Failed to Update {0}
python.packaging.notification.updated=Package {0} updated to version {1}
python.packaging.button.install.package=Install package
python.packages.no.details.in.repo=<html><head></head><body><p class="empty_description">Could not read package description from {0}.</p></body></html>
python.packaging.toolwindow.advertisement=Try the redesigned packaging support in Python Packages tool window.
python.packaging.open.toolwindow.link=Go to tool window
python.packaging.interpreter.widget.manage.packages=Manage Packages\u2026

# Conda
conda.packaging.install.progress=Installing conda package {0}
conda.packaging.uninstall.progress=Uninstalling conda package {0}
conda.packaging.update.progress=Updating conda package {0}
conda.packaging.list.progress=Reading installed conda packages
conda.packaging.cache.update.progress=Updating available conda packages list
conda.packaging.button.install.with.conda=Install with conda
conda.packaging.button.install.with.pip=Install with pip
conda.packaging.empty.pypi.info=<html><head></head><body><p class="empty_description">No package description fround on PyPI.<br/>It can still be installed with conda.</p></body></html>
conda.packaging.error.rendering.description=<html><head></head><body><p class="empty_description">Couldn't retrieve package description.<br/>It can still be installed.</p></body></html>
conda.packaging.exception.timeout=Time out
conda.packaging.exception.non.zero=Non-zero exit code

# pyproject.toml
INSP.NAME.pyproject.packages=Depencencies in pyproject.toml
python.pyproject.package.completion.tail=Python package
python.pyproject.package.not.installed=Package {0} is not installed
python.pyproject.install.package=Install package {0}
python.pyproject.install.self.as.editable=Run 'pip install -e .'
python.pyproject.install.self.as.editable.progress=Running 'pip install -e .'
python.pyproject.install.self.error=Error Running 'pip install -e .'

# Python Packages toolwindow
python.toolwindow.packages.installed.label=Installed
python.toolwindow.packages.custom.repo.searched={0} ({1} found)
python.toolwindow.packages.custom.repo.invalid={0} (Authorization failed)
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.delete.package=Uninstall
python.toolwindow.packages.update.package.version=Update {0} -> {1}
python.toolwindow.packages.update.packages=Update Packages
action.python.packages.install.text=Install
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.description.panel.loading=Loading Package info\u2026
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.rst.parsing.failed=Failed to parse the description
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.converting.description.progress=Reading package description
python.toolwindow.packages.documentation.local.interpreter=PyCharm need at least one local interpreter to display package documentation.
python.packages.dictionary.name=Python Packages Dictionary

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

# Python run target language
python.language.configure.label=Python Configuration
python.language.run.label=Run Python application

configurable.name.python.language=Python Language
python.interpreter.label=Python interpreter:
path.to.python.interpreter.dialog.title=Path to Python Interpreter
python.interpreter.banner.slogan=Python Interpreter ''{0}''

# 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 a window with the command queue
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
notification.group.sciview.advertiser=Python scientific view recommended
notification.group.cython=Python debugger native extension available
notification.group.package.requirements=Python package requirements
python.interpreters.add.interpreter.action.text=Add New Interpreter
python.interpreters.remove.interpreter.action.text=Remove Interpreter
python.interpreters.rename.interpreter.action.text=Rename
python.interpreters.show.interpreter.paths.text=Show Interpreter Paths
python.interpreters.rename.interpreter.dialog.message=New name:
python.interpreters.rename.interpreter.dialog.title=Rename Python Interpreter
rename.python.interpreter.dialog.provide.name.error.text=Provide a name for Python interpreter.
rename.python.interpreter.name.already.exists.error.text=Python interpreter with the same name already exists.

pandas.completion.type.text=DataFrame: {0}
dict.completion.type.text=dict key
python.sdk.configurable.name=Python SDK

inlay.hints.usages.text={0,choice, 0#no usages|1#1 usage|2#{0,number}'{1,choice, |1#+}' usages}
inlay.hints.usages.with.dynamic.text={0,choice, 0#no usages|1#1 usage|2#{0,number} usages} ({1,choice, 1#1 dynamic|2#{1,number} dynamic})

# Black formatter
black.configurable.name=Black
black.formatting.service.name=Black formatter
black.not.installed.error=Black formatter package is not installed on the current interpreter
black.remote.sdk.error=Package mode is not available for remote SDKs. Please use Binary mode.
black.install.button.label=Install Black
black.use.section.label=Use Black formatter:
black.enable.black.checkbox.label=On code reformat
black.enable.action.on.save.label=On save
black.advanced.settings.panel.title=Advanced settings
black.empty.output.error=Black formatter returned empty output
black.empty.path.to.executable.exception.text=Black executable not found or empty
black.action.on.save.name=Run Black
black.action.on.save.package.info=Using Black package v{0}
black.action.on.save.executable.info=Using Black executable v{0}
black.action.on.save.executable.path.not.specified=Black executable path not specified
black.formatting.with.black=Formatting with Black
black.no.lines.changed=Black: No lines changed. Content is already properly formatted.
black.formatted.n.lines=Black: Formatted {0} {1, choice, 0#lines|1#line}
black.installing.modal.title=Installing Black formatter
black.installation.error.title=Failed to install Black formatter
black.failed.to.format.on.save.error.label=Black: Failed to format file {0}
black.processing.file.name=Black: Processing file {0}
black.exception.error.message=Black formatter error
black.file.ignored.notification.label=Black: File ignored
black.file.ignored.notification.message=File {0} ignored according to --exclude or --force-exclude rules
black.advertising.service.notification.title=Black formatter integration
black.advertising.service.found.in.packages=Black formatter package is detected on the project interpreter. Try Black formatter integration!
black.advertising.service.found.in.PATH=Black formatter executable is detected in {0, choice, 0#%PATH%|1#$PATH}. Try Black formatter integration!
black.advertising.service.configure.button.label=Configure
black.advertising.service.dont.show.again.label=Don't show again
black.select.path.to.executable=Select path to Black formatter executable
black.execution.mode.label=Execution mode:
black.executable.label=Black executable:
black.executable.auto.detected.path=Auto-detected: {0}
black.executable.not.found=Unable to auto-detect Black executable in {0, choice, 0#%PATH%|1#$PATH}
black.execution.mode.package=Package
black.execution.mode.binary=Binary
black.execution.mode.tooltip.text=Use either executable or package installed on the project interpreter
black.cli.args.text.field.label=Settings:
black.cli.args.comment=List command line arguments separated by whitespace. <a href='https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#command-line-options'>Learn more</a><br>\
  Settings from pyproject.toml are applied automatically for Black v21.4.0 and higher.
black.cli.args.validation.notification=No value passed for parameter {0}
black.sdk.not.configured.error=No project SDK configured for the project {0}
black.sdk.not.configured.error.title=SDK not configured
black.remote.sdk.exception.text=Black formatter invocation in Package mode is not allowed on remote SDKs
black.interpreter.selection.combobox.label=Python interpreter:
black.format.fragment.inline.error=Black: Failed to format fragment: {0}

inlay.parameters.python.show.class.constructor.call.parameter.names=Class constructor calls
inlay.parameters.python.show.hints.for.non-literal.arguments=Non-literal arguments
inlay.parameters.python.hints.blacklist.explanation=\
  <p>To disable hints for a method or a function, use one of the following patterns:</p>\
  <ul>\
    <li><code><b>(*info)</b></code> - all functions with a single parameter whose name ends with <em>info</em><br></li>\
    <li><code><b>(a, b)</b></code> - all functions with parameters <em>a</em> and <em>b</em><br></li>\
    <li><code><b>*.put(self, key, value)</b></code> - all <em>put</em> methods with parameters <em>key</em> and <em>value</em><br></li>\
    <li><code><b>Foo.bar(self, a, b)</b></code> - method <em>bar</em> of class <em>Foo</em> with parameters <em>a</em> and <em>b</em><br></li>\
    <li><code><b>foo(\\&lt;star\\&gt;\\&lt;star\\&gt;kwargs)</b></code> - function <em>foo</em> with parameter <em>**kwargs</em><br></li>\
  </ul>\
  <p>Names or placeholders must be provided for all parameters, including the optional ones.<br>\
  Qualified method names must include class names, or placeholders for them.<br>\
  Use the "Do not show hints for current method" {0} action to add patterns from the editor.</p>

# Requirements
INSP.GROUP.requirements=Requirements
INSP.requirement.uninstalled.name=Requirement is not satisfied
INSP.requirements.package.not.installed=Package {0} is not installed
QFIX.NAME.install.requirement=Install package {0}
QFIX.NAME.install.all.requirements=Install all missing packages
live.template.propsd.description=Property getter/setter/deleter
live.template.props.description=Property getter/setter
live.template.prop.description=Property getter
live.template.compdi.description=Dict comprehension with 'if'
live.template.compd.description=Dict comprehension
live.template.compsi.description=Set comprehension with 'if'
live.template.comps.description=Set comprehension
live.template.compgi.description=Generator comprehension with 'if'
live.template.compg.description=Generator comprehension
live.template.compli.description=List comprehension with 'if'
live.template.compl.description=List comprehension
live.template.itere.description=Iterate (for ... in enumerate)
live.template.iter.description=Iterate (for ... in ...)
live.template.main.description=if __name__ == '__main__'
live.template.super.description='super(...)' call

configurable.PythonCodeCompletionConfigurable.display.name.python=Python
configurable.PythonCodeCompletionConfigurable.border.title=Python
configurable.PythonCodeCompletionConfigurable.checkbox.suggest.importable.names=Suggest importable classes, functions and variables in basic completion
configurable.PythonCodeCompletionConfigurable.checkbox.suggest.importable.names.help=When disabled, such variants can be displayed by invoking the basic completion twice

# Parameter info
param.info.show.less=Show less
param.info.show.more.n.overloads=Show {0} more {1, choice, 0#overloads|1#overload}

# Advertising
advertiser.package.supported.by.pro=Maximize your efficiency with {0}
advertiser.code.cells.supported.by.pro=Code cells are supported by PyCharm Professional

action.PyInstallPackage.text=Install
action.PyInstallFromDiskPackage.text=Install From Disk\u2026
action.InstallFromVcsPackageAction.text=Install From VCS\u2026
action.PyManageReposAction.text=Manage Repositories
action.PyDeletePackage.text=Uninstall
action.PyUpdateToLatestPackage.text=Update to Latest
action.PyChangeVersionPackage.text=Change Version
action.PyInstallWithOptionPackage.text=Install with Options
python.toolwindow.packages.deleting.text=Uninstalling\u2026
progress.text.installing=Installing\u2026
package.install.with.options.dialog.message=Options:
package.install.with.options.dialog.title=Package Install with Options
python.toolwindow.packages.collapse.all.action=Collapse All
django.template.language=Template Language
python.error=Error


python.survey.user.job.notification.group=PyCharm Job Survey
python.survey.user.job.notification.title=Feedback In IDE
python.survey.user.job.notification.content=Tell us about your Python development experience. Just one question.

python.survey.user.job.dialog.title=Feedback
python.survey.user.job.dialog.blocks.top=Python development
python.survey.user.job.dialog.blocks.checkbox.group=What do you use Python for?
python.survey.user.job.dialog.blocks.checkbox.data=Data analysis
python.survey.user.job.dialog.blocks.checkbox.ml=Machine learning
python.survey.user.job.dialog.blocks.checkbox.web=Web development
python.survey.user.job.dialog.blocks.checkbox.scripts=Writing automation scripts / parsers / tests / system administration
python.survey.user.job.dialog.blocks.checkbox.other=Other