mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-03-22 15:19:59 +07:00
52850e21d8
Previously, such names were visible only on so-called "extended" completion, activated when the hotkey for the basic completion was hit twice. The main reason was that collecting such variants from indexes was a slow process, and we didn't want to harm the responsiveness of completion for basic names. Now it becomes possible thanks to a number of performance optimizations: * Instead of using three separate indexes for classes, functions and variables, we use one -- PyExportedModuleAttributeIndex. By definition, it includes only top-level "importable" names, so we additionally save time by not filtering out irrelevant entries. Also, it doesn't contain private definitions starting with an underscore. It might bother some users, but given that the previous completion was used extremely rarely, and the new one is going to be visible everywhere, it seems that pruning unlikely entries as much as possible is a fare tradeoff. In the future, we might enable them back on the "extended" completion if there is a demand. Also, this index binds its keys to the project (`traceKeyHashToVirtualFileMapping`), further eliminating useless index lookups. * Thanks to the recent fixes in the platform (IJPL-265), it's now possible to simultaneously iterate over all keys in an index and request values for a given key without deadlocks, which is much faster than eagerly fetching all keys first. * While scanning through all matching entries from indexes, we terminate the lookup if the number of items exceeds the size of the lookup list. We can further reduce this number by adjusting the "ide.completion.variant.limit" registry value. * Calculating expensive "canonical" import paths (e.g. "pkg.private.Name" is importable as "pkg.Name") is offloaded to a background thread thanks to the `withExpensiveRenderer` API. We still calculate these paths synchronously, though, for names whose raw qualified names contain components starting with an underscore to decide whether these private names are publicly re-exported and, hence, should be displayed. The rest of the work has been put into reducing the number of entries on the list, e.g. * The prefix under caret is now matched from the beginning of a name, e.g. `Bar<caret>` matches `BarBaz`, but not `FooBar`. * We don't suggest imported names clashing with those already available in scope. * Some kinds of definitions are not suggested in specific contexts, e.g. functions and variables are not suggested inside patterns and type hints. * Nothing is suggested at the top-level of a class body, where dangling reference expressions or calls are not normally expected. Additionally, we don't suggest names from .pyi stubs at the moment, because it pollutes the suggestion list with entries coming from the stubs for third-party packages in Typeshed. We should probably enable them back once we are able to properly disable Typeshed entries for not installed packages. Some legacy forms of completion are left in the extended mode. In particular, qualified names of classes are offered inside string literals only in this mode. Also, module and package names are suggested only in the extended mode, because top-level packages and modules are already suggested for the basic completion by PyModuleNameCompletionContributor. A few tests in PyClassNameCompletionTest were updated or removed entirely because * we no longer suggest private names * we no longer suggest names from private modules not re-exported in a public module * we no longer suggest names clashing with those already available in scope * prefix matching policy was changed to start at the beginning of an identifier The whole feature can be disabled with the option "Suggest importable classes, functions and variables in basic completion" in settings. GitOrigin-RevId: 0787d42ce337b73b01a60f0bb7aa434fee43e659
1522 lines
91 KiB
Properties
1522 lines
91 KiB
Properties
### Quick-fixes ###
|
|
QFIX.add.import.add.import=Add "''{0}''"
|
|
|
|
#PyImplementMethodsQuickFix
|
|
QFIX.NAME.implement.methods=Implement abstract methods
|
|
|
|
QFIX.NAME.change.signature=Change signature
|
|
QFIX.change.signature.of=Change the signature of {0}
|
|
|
|
QFIX.FAMILY.NAME.rename.element=Rename an element
|
|
QFIX.NAME.rename.element=Rename the element
|
|
|
|
QFIX.ignore.unresolved.reference=Ignore 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.name=An invalid Python interpreter name ''{0}''!
|
|
sdk.select.path=Select Python Interpreter
|
|
runcfg.unittest.dlg.pattern=Pattern:
|
|
|
|
runcfg.testing.no.test.framework=No {0} runner found in the selected interpreter
|
|
|
|
runcfg.error.message.failed.to.find.free.socket.port=Failed to find free socket port
|
|
runcfg.error.message.cannot.find.python.interpreter=Cannot find Python interpreter for this run configuration
|
|
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.select.conda.path.title=Select Path to Conda Executable
|
|
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:
|
|
|
|
# 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.execution.exception.error.running.poetry.message=Error Running 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.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.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...
|
|
python.sdk.action.add.interpreter.based.on.target.text=On {0}...
|
|
|
|
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.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}.venv
|
|
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.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.pipenv.path=Path to pipenv:
|
|
sdk.create.custom.pipenv.missing.text=No pipenv executable found.
|
|
sdk.create.custom.poetry.path=Path to poetry:
|
|
sdk.create.custom.poetry.missing.text=No poetry executable non found.
|
|
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.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
|
|
|
|
# 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.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}
|
|
|
|
# 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.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.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...
|
|
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...
|
|
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
|
|
|
|
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>\\ \\ <a href="#no">No</a>
|
|
|
|
python.compatibility.inspection.advertiser.using.six.warning.message=\
|
|
Your source code imports the 'six' package.<br/>\
|
|
Would you like to enable Code compatibility inspection?<br/>\
|
|
<a href="#yes">Yes</a>\\ \\ <a href="#no">No</a>
|
|
|
|
# Both placeholders are Python versions like 2.7, 3.7, etc.
|
|
python.compatibility.inspection.advertiser.version.stale.python3.version.warning.message=\
|
|
Code compatibility inspection is configured for Python versions up to {0}.<br/>\
|
|
Would you like to enable it for Python {1}?<br/>\
|
|
<a href="#yes">Yes</a>\\ \\ <a href="#no">No</a>
|
|
|
|
python.install.framework.ensure.installed=Ensuring {0} is installed
|
|
python.install.framework.checking.is.installed=Checking if {0} is installed\u2026
|
|
python.install.framework.installing=Installing {0}\u2026
|
|
py.commandline.configure=Configures Python SDKs for the project
|
|
|
|
python.task.cannot.find.python.interpreter.for.selected.module=Cannot find a Python interpreter for selected module
|
|
python.unknown.project.synchronizer.this.interpreter.type.does.not.support.remote.project.creation=This interpreter type does not support remote project creation
|
|
progress.text.connecting.to.console=Connecting to console\u2026
|
|
progress.title.debugger.connection=Debugger connection
|
|
python.sdk.configuration.tab.title=Classes
|
|
python.console.rename.message=Enter new console name:
|
|
python.introduce.variable.refactoring.name=Introduce Variable
|
|
|
|
settings.completion.ml.python.display.name=Python
|
|
QFIX.pep8.edit.inspection.profile.setting=Edit inspection profile setting
|
|
|
|
python.remote.process.starter.can.t.run.remote.interpreter=Cannot run the remote Python interpreter: {0}
|
|
python.remote.interpreter.can.t.create.project.this.type=Cannot create a project of this type on a remote interpreter. Choose local interpreter.
|
|
dialog.message.error.on.python.side.exit.code.stderr.stdout=Error on Python side. Exit code: {0}, err: {1} out: {2}
|
|
live.template.context.class=Class
|
|
live.template.context.top.level=Top-level
|
|
|
|
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
|
|
framework.not.supported.for.the.selected.interpreter={0} is not supported for the selected interpreter
|
|
|
|
action.MarkNamespacePackageDirectory.text=Namespace package
|
|
python.unmark.as.namespace.package=Unmark as Namespace Package
|
|
python.unmark.as.python.namespace.package=Unmark as Python Namespace Package
|
|
python.namespace.package.folder=Namespace Package
|
|
python.python.namespace.package.folder=Python Namespace Package
|
|
python.namespace.packages.name=Namespace packages
|
|
python.namespace.packages.description=Namespace Package Folders
|
|
dialog.title.can.t.create.package=Create Package Error
|
|
command.name.create.new.package=Create New Package {0}
|
|
dialog.title.new.python.package=New Python Package
|
|
new.package.list.item.ordinary.package=Package
|
|
new.package.list.item.namespace.package=Namespace package
|
|
|
|
# Python 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=Delete Package
|
|
python.toolwindow.packages.install.link=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.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(\\<star\\>\\<star\\>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}
|