Saravanan666/pypi-org huggingface dataset:
Package: plover-next-stroke
Next Stroke Suggestions for PloverThis is a plugin that displays the possible options for the next few strokes.InstallationYou can install this plugin using the built-in Plover Plugin Manager, under the nameplover-next-stroke.Usage NotesMacro Strokes & ShortcutsTo make full use of the plugin, you'll have to define a few additional entries in your dictionary to navigate the menu (They won't be added automatically!). The recommended strokes are just what I use personally, so it's okay if you'd like to use something else.ActionDictionary DefinitionRecommended StrokeNext Page=ns_next_page#WRPrevious Page=ns_prev_page1KReload Suggestions=ns_reload1KWRSince the plugin keeps an internal copy of your dictionaries to load suggestions quicker, you'll have to manually reload this internal copy with a reload stroke whenever you add or delete entries to/from any of your dictionaries. You don't need to trigger a manual update if you're switching languages or activating/deactivating dictionaries.Display Order TypesDisplay OrderExplanationFrequencyOrder by lowest stroke count first, then when stroke counts are equal, order by most frequent first based on system orthography list (if available)Frequency (Prioritize Numbers)Same as Frequency, but strokes containing numbers are prioritized and ordered by numeric value.Frequency (Prioritize Non-numberic)Same as Frequency, but strokes containing numbers are pushed to the back.Stroke CountOrder by lowest stroke count first, preserving original dictionary order.AlphabeticalOrder by translation alphabetically.System DefinedOrder defined by the system. The default English stenotype system doesn't have a defined display order. Defaults to Frequency.System-defined functionsIf you're designing a language system for Plover and you'd like to customize the display order and format (for instance, converting certain strokes to numbers), you may do so by including these functions in your system file:defNS_STROKE_FORMATTER(stroke:str)->str:"""Formats single strokes, such as STROEBG"""return...defNS_TRANSLATION_FORMATTER(translation:str)->str:"""Formats the translated string, such as 'stroke'"""return...defNS_SORTER(entry:Tuple[Tuple[str],str])->int:"""Scores outline-translation pairs, such as (("TRAPBS", "HRAEUT"), "translate")Pairs are ordered from smallest to biggest;it need not be an int - anything that can be comparedworks, including strings or tuples of ints."""outline,translation=entryreturn...All next stroke suggestions will be run through the two formatters (if available) before being sorted. The sorter will only be used if the user changes their display order to "System Defined".License & CreditsThis plugin is licensed under the MIT license.The icons used in this plugin are taken fromIcons8 Flat Color Icons.
Package: plover-ninja
Plover NinjaWhat does Plover Ninja do?Plover Ninja notes the words that you steno and how long it takes to write these words. Based on this information, it is able to do some neat analysis. The plugin can:Determine which words take the longest to write on averageDetermine which words you haven't ever written beforeBased on this kind of information, Plover Ninja can make some practice recommendations. In order for its suggestions to be useful, Plover Ninja keeps in mind which words are used most frequently (based onthis data). With this information in mind, the plugin can suggest:Words that are worth practicing, because they are both slowandare fairly commonThe most common words that you have never written beforeWhile there are several tools that can help you practice steno, Plover Ninja is unique in that all of its feedback is based on the things you actually write. If you write an email and hit a tricky word, Plover Ninja will see that and be able to point that out later. If you've never used a common word, Plover Ninja will let you know so that you can grow your vocabulary with useful words.SetupOnce you have installed Plover Ninja using thePlover Plugins Manager, you will need to enable the plugin in Plover.To do this, first click on the Configure gear icon:.. then, click on the Plugins tab and click to enable theninja_extension.UsageYou interact with Plover Ninja by.. writing commands! The general format of each command is:Command phrasefollowed by three returns. The three returns are a special cue to Plover Ninja that what you just wrote should be interpreted as a command. If Plover Ninja recognizes your command, it will take action!Here is a list of commands currently supported by Plover NinjaI am ready to practiceEnteringI am ready to practicefollowed by three returns will generate some suggestions for practice words. Currently this includes two sections:A list of common words that you have not written yet, andA list of words that take a while to write, on average, and are fairly commonThe output from this command will look something like this:Show statsEnteringShow statsfollowed by three returns will list how many words you have steno-ed each day.The output from this command will look something like this:There are a few variations on this command, which show your daily word count for different lengths of time:Show weekwill show you daily stroke counts for the past week, andShow monthwill show you daily stroke counts for the past monthFAQQ: When entering a command, does the case matter?A: Nope! Feel free to use any caseQ: Where does Plover Ninja store its data?A: In aSQLitedatabase located at$USER_HOME/.plover_ninja/ninja.dbQ: What steps does Plover Ninja take to protect my data?A:All Plover Ninja data remains local.Yourninja.dbdatabase is created with user-only read, write, and execute permissions.
Package: plover-open-url
Command plugin forPloverto open a URL, a
folder, or files.The package is available onGitHubandPyPI.UsageIn order to use this plugin inPloveryou need to
create a dictionary entry of the form:{"example_stroke":"{PLOVER:OPEN_URL:url}"}For example, if you wanted to open Google:{"example_stroke":"{PLOVER:OPEN_URL:https://www.google.com}"}or if you wanted to open Program Files on Windows:{"example_stroke":"{PLOVER:OPEN_URL:C:\\Program Files}"}LicenseThe MIT License.
Package: plover-palantype
Possum Palantype support for Plover.Activating PalantypeAfter installing this plugin, you need to turn on Palantype in Plover:In Plover’s configuration, go to theSystemstab, and change the active system toPossum Palantype.In Plover’s machine tab, select thePalantypemachine and ensure the settings point to your Palantype machine.“Palantype” machine type in Plover is what other CAT software calls “Palantype B”.If you have aNeutrinomachine, you may need to select the “Gemini PR” protocol.If you do not own a Palantype machine, you can use an N-key rollover keyboard instead, as outlined inthis tutorial.At this time, other protocols are not supported.Plover will installsample.jsonanduser.jsonas dictionaries. You can remove the sample if you already have your own dictionary or want to start from scratch. Plover acceptsjsonandRTFdictionaries. It is recommended to useuser.jsonwhen adding new strokes.Note: at the moment,onlyULFTSis supported to backspace the last stroke.Common CommandsIt would be a good time to define some custom commands that make using Plover much easier!The “Add Definition” button lets you define a new dictionary entry. The first recommended entry is one that summons this dialog!T+UPT:{PLOVER:ADD_TRANSLATION}(think “dictionary update”)Some other useful translations for you to define (come up with your own strokes):{-|}capitalize next word{^^}suppress space{#right},{#left},{#up},{#down}press arrow keys: right, left, up, down (recommendation is to create an arrow-key cluster on one hand with a chord on the other){#control(c)}copy on Windows, Linux, or{#command(c)}for Mac{#control(v)}paste on Windows, Linux, or{#command(v)}for Mac{#control(z)}undo on Windows, Linux, or{#command(z)}for Mac{#tab}press the tab key{#alt(tab tab)}change application on Windows{#backspace}press the backspace key{#escape}press the escape key{#return}press the return/enter key{^\n^}{-|}new line, capitalize{^\n\n^}{-|}new paragraph, capitalize
Package: plover-palantype-DE
Palantype DESeeChangelog.This is a complete rework of the Possum Palantype steno system for efficient
use with the German language.
Its intended use is with a keyboard, not an actual Palantype machine.
Each finger operates three keys: Home row, top and bottom.
The thumbs are exceptions, they operate four keys.
There is no simultaneous pressing of multiple keys with one finger.Like the original Palantype, this adaption is compatible with
Qwerty-keyboards as long as they support N-key roll-over (NKRO).
The optimal experience is to be expected with a keyboard that allows full use of the thumbs.Palantype DErelies on four thumb keys.
Here are examples for such a keyboard:Keyboardio Model 100Keyboardio AtreusZSA Moonlander Mark IErgodox EZYAEMKHow to useQuick startHead over topalantype.comto get started right away in
the browser.Offline use with PloverThis is a plugin for the software Plover fromThe Open Steno Project.
Download thelatest version of Plover.
Plover supports plugins from v4.0.0 on.After installing this plugin, you need to turn on Palantype in Plover:In Plover's configuration, go to theSystemstab, and change the active system toPalantype DE.In Plover's machine tab, selectkeyboard.Run in browserCurrently, only the tutorial is implemented atpalantype.com.
Learning to type requires a lot of practice,
therefore it is recommended starting there in any case.In future,palantype.comwill also offer
an on-line text editor for steno typing.Current stateThe dictionary contains almost 2,000,000 words of the German language.
There are built-in already some essential features for real-life steno typing:fingerspellingcommand keys (e.g. arrow keys, home, end, ...)numbersspecial keysplover commands (e.g. retroactively capitalize)These features are implemented in the dictionary filespalantype-DE-extra.json, andpalantype-DE-numbers.json.DevelopmentSource codeYou can find all relevant code on Github:The plover pluginplover-palantype-DEThe palantype Haskell librarymypalantypePalantype tools, to create your own palantype-style steno systemThe code of the project home page with all the tutorialsPalantype.com codebaseYou can get an overview of what I am working on, on theKanban board of the project.
Feel free to post issues on any of those repositories with questions and/or feedback.Getting your hands dirtyTest the plugin locally$ plover -s plover_plugins install -e .
$ ploverPublish new version$ nix-shellFollow the instructions inside the nix shell.AcknowledgmentsThe current list of over 100'000 words uses word frequency information to
resolve collisions, i.e. ambiguous steno chords.
The word frequency information has been provided by
the Natural Language Processing Group, Uni Leipzig.
It is generated out of acorpus of 35 Million sentencesand distributed under
theCreative Commons Attribution-NonCommercial 4.0 International Public Licence.
Package: plover-palantype-german
Plover Palantype GermanPossum Palantype support for Plover for German with two additional keys.The dictionaries can be found here:https://github.com/percidae/plover_palantype_german/tree/master/plover_palantype_german/dictionariesActivating PalantypeAfter installing this plugin, you need to turn on Palantype in Plover:

1. In Plover's configuration, go to the ``Systems`` tab, and change the active system to ``Possum Palantype German``.
2. In Plover's machine tab, select the ``Palantype`` machine and ensure the settings point to your Palantype machine.

    - "Palantype" machine type in Plover is what other CAT software calls "Palantype B".
    - If you have a *Neutrino* machine, you may need to select the "Gemini PR" protocol.
    - To use all keys you need a Gemini PR protocol dedicated hardware
    - If you do not own a Palantype machine, you can use an N-key rollover keyboard instead, as outlined in `this tutorial <http://www.openstenoproject.org/palantype/tutorial/2016/08/21/learn-palantype.html>`_.
    - At this time, other protocols are not supported.

3. Plover will install ``sample.json`` and ``user.json`` as dictionaries. You can remove the sample if you already have your own dictionary or want to start from scratch. Plover accepts ``json`` and ``RTF`` dictionaries. It is recommended to use ``user.json`` when adding new strokes.
4. Note: at the moment, **only** ``ULFTS`` is supported to backspace the last stroke.

Common Commands
~~~~~~~~~~~~~~~

It would be a good time to define some custom commands that make using Plover much easier!

The "Add Definition" button lets you define a new dictionary entry. The first recommended entry is one that summons this dialog!

- ``T+UPT``: ``{PLOVER:ADD_TRANSLATION}`` (think "dictionary update")

Some other useful translations for you to define (come up with your own strokes):

- ``{-|}`` capitalize next word
- ``{^^}`` suppress space
- ``{#right}``, ``{#left}``, ``{#up}``, ``{#down}`` press arrow keys: right, left, up, down (recommendation is to create an arrow-key cluster on one hand with a chord on the other)
- ``{#control(c)}`` copy on Windows, Linux, or ``{#command(c)}`` for Mac
- ``{#control(v)}`` paste on Windows, Linux, or ``{#command(v)}`` for Mac
- ``{#control(z)}`` undo on Windows, Linux, or ``{#command(z)}`` for Mac
- ``{#tab}`` press the tab key
- ``{#alt(tab tab)}`` change application on Windows
- ``{#backspace}`` press the backspace key
- ``{#escape}`` press the escape key
- ``{#return}`` press the return/enter key
- ``{^\n^}{-|}`` new line, capitalize
- ``{^\n\n^}{-|}`` new paragraph, capitalize
Package: plover-per-application-state
Plover Per-Application StatePlover plugin to make translation state function per application window and tab.DISCLAIMER:This plugin is still WIP andwillcause Plover to function incorrectly under some circumstances.InstallationNavigate to the installation directory for Plover and open a terminal / command prompt.Run:<exe_name> -s plover_plugins install -e plover-per-application-stateTheplover-application-controlsplugin should be
installed automatically as a dependency.Restart Plover.Configure > Plugins > Enable bothapplication_controlsandper_application_state.To disable the plugin at any point, disableper_application_state.Disablingapplication_controlswill prevent the plugin from being able to detect the currently active window.Important Dictionary Setup:Any dictionary entries which result in a window being switched will need to be modified to include{PLOVER:per_application_state:prevent_merge}at the start of the translation. This is to ensure that the plugin
correctly reloads state when the window is switched.For example{#Control(tab)}will need to be modified to{PLOVER:per_application_state:prevent_merge}{#Control(tab)}.This is NOT required for any{PLOVER:application:}commands fromplover-application-controls.Commands:The{PLOVER:per_application_state}command can be used to control state management. It takes a subcommand as its first
argument, with further arguments separated by:.For example,{PLOVER:per_application_state:clear_all}will clear all state.Window CommandDescriptionArgumentsclearClear the translation state for the current window tabclear_allClears the current and stored translation states for all windowsclear_windowClears the current and stored translation states for the current active windowprevent_mergeTemporarily prevents state from being merged when a title changes as a result of a stroke
Package: plover-phenrsteno
Stenotype layout for PhenrstenoNon-rhotic phonemic system forPlover. See thewikito learn
more.InstallationInstallPlover version
4.x.xIn the main Plover window, selectPlugins Managerfrom the
toolbarIn the plugins list, find and select plover-phenrsteno and clickInstall/UpdateQuit (Ctrl-q) and re-open PloverIn the main Plover window, selectConfigureGo to theSystemtabSelectPhenrstenofrom the dropdown boxClickOKUsageOnce installed, you have two options:Use someone else’s dictionariesCreate your ownYou candownload my dictionaries from this
repository.verbatim.jsonis for fingerspelling individual letters.vocabulary.json,prefixes.json, andsuffixes.jsonare for
transcribing (British) English words.In Plover, click the big green plus icon to add dictionaries.
Package: plover-phoenix-stenotype
Phoenix StenotypeThe default stenotype system in Plover translates words likeKATDascattedwhen it shouldn't translate at all.Of course you can just useplover-minimal-english-stenotype, but this plugin includes certain orthography rules that are compatible with the Phoenix dictionary for convenience.This plugin allows you to type words likeembiggening(automatically doubling the letter g) without defining a new dictionary entry, for example. It also enables you to write words likeladiesandoccurredin three separate strokes—If you decide to do that for some reason.
Package: plover-plugins-manager
Plover Plugin ManagerRelease history0.7.1fix editable installation (ensure UI files are properly generated)0.7.0tweak custom info widget's API for reuse in other plugins0.6.3fix Python packaging0.6.2fix compatibility withrequests-cache>=0.8.00.6.1minor tweaks to make packaging for AUR easier0.6.0warn users about the security risk when installing pluginsfix plugin install/removal when running in a Python virtual environment0.5.16stop using PyPI's (disabled) XMLRPC search endpoint, and switch to a self-hosted registry of
available plugins (maintained athttps://github.com/openstenoproject/plover_plugins_registry).0.5.15fix support for cancelling an install/update/removal operation on Windows.0.5.14drop the use of pip's internal APIsdrop the dependency on PyQt5 WebEngineimprove and simplify cache handling: persistently cache all network
requests (with a 10 minutes expiration date)support for Python 3.80.5.13add support forpip>=18.0add support forPyQt5>=5.11add support for Markdown plugin descriptions0.5.12improve handling of plugins when user site is disabled: always list the
version for the user installed plugin (even if it's older than the system
package version and user site packages are disabled)disable pip version checkadd support forpip>=10.00.5.11plugins are now handled even if they can't be loaded by Plover
(so it's possible to update/uninstall broken plugins)0.5.10fix #5: open all links externally0.5.9refresh PyPI metadata in the backgroundcache PyPI metadata for 10 minutesdo not crash if connection to PyPI failsCreditsIcon made byFreepikfromwww.flaticon.com.
Package: plover-practice-plugin
Plover Practice PluginThisPloverpluginproject contains examples of the following types of
plugins:Command(e.g."{:COMMAND:OPEN_URL:https://www.openstenoproject.org/}")Meta(e.g."{:RANDOM_NUMBER:1:100}")Extension(e.g."{:GET_ENV_VAR:$USER}")It is a companion repo to the following blog post:Creating Plover Plugins with PythonThis plugin is meant for educational purposes only, and hence deliberately not
entered into thePlover Plugins Registry, so it will not show up in Plover's
Plugins Manager (though it has be released toPyPI, where you can find ithere).InstallI recommend following the blog post to build out the plugin yourself, but if you
just want to test it out on your machine, you can install it usingGit:gitclonegit@github.com:paulfioravanti/plover-practice-plugin.gitcdplover-practice-plugin
plover--scriptplover_pluginsinstall--editable.Whereploverin the command is a reference to your locally installed version
of Plover. See theInvoke Plover from the command linepage for details on
how to create that reference.Enabling the ExtensionAfter re-opening Plover, open the Configuration screen (either click the
Configuration icon, or from the main Plover application menu, selectPreferences...)Open the Plugins tabCheck the box next toplover_practice_pluginto activate
the plugin
Package: plover-python-dictionary
Plover Python dictionaryAdd support for Python dictionaries to Plover.UsageA Python dictionary is simply a single UTF-8 source file with the following API:# Length of the longest supported key (number of strokes).LONGEST_KEY=1# Lookup function: return the translation for <key> (a tuple of strokes)# or raise KeyError if no translation is available/possible.deflookup(key):assertlen(key)<=LONGEST_KEYraiseKeyError# Optional: return an array of stroke tuples that would translate back# to <text> (an empty array if not possible).defreverse_lookup(text):return[]For example save the following code toshow_stroke.py:Note: make sure the file encoding is UTF-8!LONGEST_KEY=2SHOW_STROKE_STENO='STR*'deflookup(key):assertlen(key)<=LONGEST_KEY,'%d/%d'%(len(key),LONGEST_KEY)ifSHOW_STROKE_STENO!=key[0]:raiseKeyErroriflen(key)==1:return' 'returnkey[1]Then add it to your dictionaries stack as you would a normal dictionary.Now, if you strokeSTR*, then the next stroke will be shown verbatim
(untranslated), e.g.-T STROEBG TP-R KW-GS STROEBG KR-GS S STR* STROEBGoutputs:the stroke for "stroke" is STROEBG.Release history1.1.0fix type checks forlookupandreverse_lookup:
allow bound methods and functorsfixreverse_lookupimplementation: return a set.fix__getitem__/getimplementations:
when the key length is out of boundsfix__contains__implementationfix__delitem__/__setitem__implementations:
raise the correct exception type1.0.0fix possible encoding issue when loading a dictionary:
from now on, assume and force UTF-80.5.12update changelog...0.5.11drop support for Python < 3.6fix use of deprecatedimpmodulerework tests to useplover_build_utils.testinguse PEP 517/5180.5.10fix./setup.py testhandlingfix default implementation ofreverse_lookupto return a list (not a tuple)0.5.9update to Plover's latest API
Package: plover-q-and-a
Plover Q&AThisPloverextensionplugincontainsmetasfor your
dictionaries that can assist withQ&A(Question and Answer): the process of
recording lines of questioning in a conversation involving multiple people,
usually in a legal context.More information about the concept of Q&A can be found at:Platinum Steno Lesson 27 QA videoMore information about the creation of, and reasoning behind, the outlines that
originally informed this plugin can be found at the following blog post:Plover For the RecordYou can see a video of the plugin in action here:Steno Legal Q&A Test with Plover and Vim(And if you are aVimuser and want the syntax highlighting, you can find it
in theVim Steno Q&Aplugin)InstallIn the Plover application, open the Plugins Manager (either click the Plugins
Manager icon, or from theToolsmenu, selectPlugins Manager).From the list of plugins, findplover-q-and-aClick "Install/Update"When it finishes installing, restart PloverAfter re-opening Plover, open the Configuration screen (either click the
Configuration icon, or from the main Plover application menu, selectPreferences...)Open the Plugins tabCheck the box next toplover_q_and_ato activate the pluginConfig and DictionariesSee theexamplesdirectory for example configuration and dictionaries to
help you get up and running with using this plugin for Q&A.How To UseSee theINSTRUCTIONSpage.DevelopmentClone from GitHub withgit:gitclonegit@github.com:paulfioravanti/plover-q-and-a.gitcdplover-q-and-aPython VersionPlover's Python environment currently uses version 3.9 (see Plover'sworkflow_context.ymlto confirm the current version).So, in order to avoid unexpected issues, use your runtime version manager to
make sure your local development environment also uses Python 3.9.x.TestingPytestis used for testing in this plugin.Coverage.pyandpytest-covare used for test coverage, and to run
coverage within PytestPylintis used for code qualityMypyis used for static type checkingCurrently, the only parts able to be tested are ones that do not rely directly
on Plover.Run tests, coverage, and linting with the following commands:pytest --cov --cov-report=term-missingpylint plover_q_and_amypy plover_q_and_aTo get a HTML test coverage report:coverage run --module pytestcoverage htmlopen htmlcov/index.htmlDeploying ChangesAfter making any code changes, install the plugin into Plover with the following
command:plover-splover_pluginsinstall.Whereploverin the command is a reference to your locally installed version
of Plover. See theInvoke Plover from the command linepage for details on
how to create that reference.