Saravanan666/pypi-org huggingface dataset:
Package: plover-regenpfeifer
Regenpfeifer (German stenography system) support for Plover.For now it only remaps the top S- to Z- but it is planned to add orthography rules in the future.In the versions lower than 1.0.0, -Z was remapped to -N but this was reverted as described onhttps://stenoblog.com/regenpfeifer-layout-update/.The dictionary is generated with the corresponding version ofhttps://github.com/mkrnr/regenpfeiferusing the word list fromhttps://github.com/mkrnr/wortformliste.Recommended UsageSince the regenpfeifer dictionary will change in the future, it it highly recommended to create a separate dictionary with your own mappings.InstallationTo install the cloned git repository, you can run the following command:Windows.\plover_console.exe-splover_pluginsinstall<path-to-plover-regenpfeifer-git-repo>Mac/Applications/Plover.app/Contents/MacOS/Plover-splover_pluginsinstall<path-to-plover-regenpfeifer-git-repo>Special ThanksSpecial thanks to Benoit Pierre, Ted Morin, and Nicholas Markopoulos for providing source code and valuable hints on how to set up the plugin.LicenseThis plugin is licensed under GPLv3, or any later version.
Package: plover-retro-case
################Plover Retro Case################Retroactively change the case of an already written wordUsage=====Retro Case-----------------------``{:retro_case:capPrev:capThis:deliminater?}``-  **letter**: the letter or word to fingerspell-  **capPrev**: whether to capitalise the previous word-  **capThis**: whether to capitalise the current word-  **delimiter** *(optional)*: the character or word to join stitched letters with, *defaults to ''*Examples^^^^^^^^- camelCase- camel case{:retro_case:false:true} → camelCase- PascalCase- pascal case{:retro_case:true:true} → PascalCase- snake_case- snake case{:retro_case:false:false:_} → snake_case
Package: plover-retro-everything
Plover Retro EVERYTHINGSurround words you previously typed with arbitrary translations,
allowing you to turn most mode-switching plugin into a retro-plugin!UsageAdd dictionary entries like these:"KARPS":"=retro_everything:{MODE:CAPS},{MODE:RESET})","*UPBDZ":"=retro_everything:{MODE:SET_SPACE:_},{MODE:RESET})"and that's it!
Package: plover-retro-stringop
plover_retro_stringopRun arbitrary code on the last n words!
This is inheritly unsafe and horrible, yay!Complaints go to[[redacted]]@[[redacted]].com.Usage{:retro_stringop:N:EXPR}, whereNis the number of words (backwards) to work on andEXPRis the expression that constitutes the new text.
This hastextas the entire string andwordsas an array of the individual words (already stripped, useraw_wordsfor words including the spaces).{:retro_stringop_sh:N:EXPR}does the same stuff, but calls/bin/sh, and provides the text asTEXTenv var.Examples{:retro_stringop:1:"(" + text + ")"}: surround last word in parenthesis{:retro_stringop:2:"(" + text + ")"}: surround last two words in parenthesis{:retro_stringop_sh:1:echo "$TEXT" | tee some-file.txt}: log last word to some-file.txt (tee is used here to so that the word doesn't get deleted){:retro_stringop:1:text[::-1]}: reverse the last word{:retro_stringop_sh:1:cat "$TEXT"}: read the last word as a filename, and read that file, replacing the filename with the content{:retro_stringop:3:"".join([w.lower().capitalize() for w in words])}: PascalCase the last 3 words
Package: plover-retro-surround
Plover Retro surroundSurround an arbitrary amount of words with any string after you've already written them.UsageAdd dictionary entries like these:"SPREPBS":"{:retro_surround:1:(:)}""SPREPBS/SPREPBS":"{:retro_surround:2:(:)}""SPREPBS/SPREPBS/SPREPBS":"{:retro_surround:3:(:)}"and that's it!
Package: plover-retro-untranslator
plover-retro-untranslatorConverts the last X translations to a specified format consisting of raw steno and/or a translation and/or definition (video)Examplesput these into your dictionary:{"RA*UD":"=retro_untranslator:`%r`""STRO*EBGD":"=retro_untranslator:`%r` → `%T`""TKAO*EFPBD":"=retro_untranslator:`%r` → `%D`"}example stroke ⇒ output:KWRURPB/RA*UD ⇒ `KWRURPB`
KWRURPB/STRO*EBGD ⇒ `KWRURPB` → `yes, your Honor`
KWRURPB/TKAO*EFPBD ⇒ `KWRURPB` → `yes{,}your Honor`Configuration(literally the same thing as tapey-tape)CodeItemExample%rraw stenoKWRURPB%Ddefinitionyes{,}your Honor%TtranslationYes, your Honor%%an actual%%PrerequisitesDownload plover and find the executablesee thiswebsitefor finding the location of plover depending on which platform you are using (Linux, Windows, etc.)InstallationNow run this command to install the library<plover_executable>-splover_pluginsinstallplover-retro-untranslatorDevelopersThis section shows how you can have an editable version of this projectFirstly, fork this repository (in GitHub), then clone it:gitclonehttps://github.com/your_user_name/plover-retro-untranslatorcd into this repoThen install for use!Note that "plover" is the executable that you downloaded to make Plover work in the first placeSee this [[https://plover.readthedocs.io/en/latest/cli_reference.html][website]] for the different locations depending on which platform you are using (Linux, Windows, etc)cdplover-retro-translator
plover-splover_pluginsinstall-e.AcknowledgmentsSachac'splover-retro-strokefor motivating the creation of this pluginrabbitgrowth'stapey-tapefor motivating the format of this plugin
Package: plover-roll-the-dice
Roll the DicePlover text macros to roll dice, flip a coin, and take chances.InstallationInstall from the Plover plugins manager.UsageMeta / Macro NameDescription{:roll:range:1:100}Get a random integer in the provided range (in this example, from 1 to 100, inclusive).{:roll:choice:option1:option2:etc}Randomly write a choice from the options provided (in this example,option1,option2, andetc). Spaces are allowed and the word will respect the current capitalization state.{:roll:d6}Roll a six-sided die. You can replace "6" with any positive whole number. Equivalent to{:roll:range:1:6}.{:roll:d10}Roll a 10-sided die. Equivalent to{:roll:range:0:9}.{:roll:d20}Roll a 20-sided die. Equivalent to{:roll:range:1:20}.{:roll:coin}Flip a coin. Equivalent to{:roll:choice:heads:tails}.{:roll:8ball}Ask the Magic 8-Ball a question.ExamplesYou can mix these metas into your text.{"RO*L":"I roll a d20... the result is {:roll:d20}","KO*EUPB":"Heads or tails{?}{:roll:coin}{!}","SAO*UR":"{:roll:choice:yep:sure:okay:fine by me}"}
Package: plover-rpn-calculator
RPN Calculator for PloverRPN Calculatoris a stack-based calculator that you can use to calculate equations directly in-line while writing. It uses reverse polish notation, where operations are written after their arguments, rather than in-between.CommandsDefinitionExplanation{:rpn_put:<characters>}Put characters into buffer.For example:{:rpn_put:1}{:rpn_put_ext}Put all characters after the most recent calculator command into buffer. This allows you to use regular number entry strokes rather thanrpn_putstrokes to put characters into buffer.{:rpn_del_buff}Delete rightmost character in buffer.{:rpn_clear_buff}Clear buffer.{:rpn_clear_all}Clear and delete everything.{:rpn_push}Parse and push buffer into stack.{:rpn_push_bin}Parse and push buffer into stack as binary.{:rpn_push_hex}Parse and push buffer into stack as hexadecimal.{:rpn_add}Pop(x, y)from stack (whereyis at the top) and pushx + y.{:rpn_sub}Subtraction: Pop(x, y), pushx - y.{:rpn_mul}Multiplication: Pop(x, y), pushx * y.{:rpn_div}Division: Pop(x, y), pushx / y.{:rpn_intdiv}Floor division: Pop(x, y), pushfloor(x, y).{:rpn_mod}Modulo: Pop(x, y), pushx mod y.{:rpn_pow}Exponent: Pop(x, y), pushpow(x, y).{:rpn_neg}Negation: Popx, push-x.{:rpn_and}Bitwise AND: Pop(x, y), pushx & y.{:rpn_or}Bitwise OR: Pop(x, y), push `x{:rpn_xor}Bitwise XOR: Pop(x, y), pushx ^ y.{:rpn_not}Bitwise NOT: Popx, push~x.{:rpn_lsl}Logical Shift Left: Pop(x, y), pushx << y.{:rpn_lsr}Logical Shift Right: Pop(x, y), pushx >> y.{:rpn_swap}Swap top two stack items.{:rpn_pop}Remove the topmost item.{:rpn_dup}Duplicate top stack item.{:rpn_func:<params>:<return>}Define custom function; parameters are separated by commas, and the return value is written using python syntax.For example:{:rpn_func:x,y:3*x+2*y}{:rpn_end}Mark the end of the calculation.Here are a few things to note when using the plugin:You can chain these definitions in a single stroke. For instance,"{:rpn_clear_buff}{:rpn_dup}{:rpn_put:2}{:rpn_mul}"will let you repeatedly add double the topmost item onto the stack.When the stack has exactly one item, it will be formatted as a bare number, allowing you to quickly move on after calculation.You can use the undo stroke (Typically*) to undo all RPN commands. This is helpful whenever you encounter an error during calculation.Most operations that pop from the stack will push whatever you have in the buffer onto the stack first before popping. This allows you to, for example, use{:rpn_add}to directly add the buffer to the item at the top of the stack, without the need to stroke therpn_pushcommand.
Package: plover-run-py
plover-run-pyCommand plugin for Plover to run an arbitrary Python command.Warning: While this plugin can do everything what a command plugin can, this should
only be used for personal usage. If the usage is sufficiently general, it's recommended to make
a Plover command plugin instead.It's also possible to execute a command from the command-line, usingtheplover_send_commandscript.
Unfortunately, this method takes about 1.5s per call due to Plover's overhead.Ifpython -m plover.scripts.send_commandis used, the time is reduced to 0.3s per call,
mostly because ofpkg_resourcesimport.See alsoplover-run-shellpluginfor running a shell command.plover-debugging-consolepluginfor
running Python commands in Plover in a shell (more convenient for debugging and showing results).plover-retro-stringoppluginfor
running Python commands to transform/modify the previous text using arbitrary Python expression.UsageIn order to use this plugin inPloveryou need to
create a dictionary entry of the form:{"example_stroke":"{PLOVER:PY:command}"}Variablesengineandploverare provided.Remember to escape the characters in\{}according to Plover's dictionary format.Alternatively, if the definition has the form"{PLOVER:PY_F:path}", the content of the file
at the given path will be run as Python code.Note: If the command takes a long time to finish, Plover might freeze.ExampleRefer to the API reference (1,2) (unofficial, community-maintained)
for more details.Sleep between key presses:{#a}{plover:py:import time; time.sleep(1)}{#b}Toggle a plugin and show a warning notification on the status:
(broken into multiple lines for readability)
See alsouser202729/plover-delay: Plover command plugin to sleep for some time.for a dedicated plugin.{plover:py:
engine["enabled_extensions"]^=\{'ibus'\};
plover.log.warning('ibus enabled=' + str('ibus' in engine["enabled_extensions"]))
}
Package: plover-run-shell
Plover Run ShellCommand plugin forPloverto run an arbitrary shell
command.The package is available onGitHubandPyPI.Common issuesThe subprocess inherits Plover's environment, and some plugins might set some environment variables.For instance, on some operating systems,plover-debugging-consolemay setPAGERenvironment variable. (seeissue #2)
You may want to unset them explicitly, for example on systems withenv:env -uPAGER -uGIT_PAGER xtermAlternatively, install a sufficiently new version of packagebackground-zmq-ipython,
see README ofplover-debugging-consolefor more details.UsageIn order to use this plugin inPloveryou need to
create a dictionary entry of the form:{"example_stroke":"{PLOVER:SHELL:command}"}Note:The command might be executed synchronously (so you can use&on Linux orstarton Windows if
you don't want Plover to freeze, in case the called process is long-running).(on UNIX systems) The command may be executed by theshshell.  If you want to use another
shell, you can call that shell explicitly:bash -c "command".ExampleThese examples are only for X on GNU/Linux systems (it relies on many external tools).You should be able to construct similar translations by searching for "how to do task X from
console/command-line".If there's none, you can still write an external program with other programming language and call it
from Plover. (alternatively, write it in Python and make a command plugin)Alternatively, if you already have a working binding in the windows manager, you don't have to use
this plugin and use Plover's key combination syntax.Shutting down the machine"{PLOVER:SHELL:\\{ sleep 2s;poweroff; \\}&}{PLOVER:QUIT}"Restart Plover (console GUI, in a new terminal)"{PLOVER:SHELL:xterm -e bash -c \"sleep 0.5s; plover --gui console\" &}{PLOVER:QUIT}"Change brightness"{PLOVER:SHELL:xbacklight -10}"
"{PLOVER:SHELL:xbacklight +10}"Change volume (note that the solution withpactlis not robust because it relies on the sink
number being 0)"{PLOVER:SHELL:pactl set-sink-volume 0 -5%}"
"{PLOVER:SHELL:pactl set-sink-volume 0 +5%}"
"{PLOVER:SHELL:amixer -D pulse sset Master 5%+}"
"{PLOVER:SHELL:amixer -D pulse sset Master 5%-}"Suspend (depends on your GNU/Linux distribution)"{PLOVER:SHELL:systemctl suspend}"
"{PLOVER:SHELL:pm-suspend}"
Package: plover-russian-trillo
The Trillo Russian Realtime stenography system for Plover.Activating TrilloAfter installing this plugin, you need to turn on Trillo in Plover:In Plover’s configuration, go to theSystemstab, and change the active system toRussian Trillo.You will need a Tréal machine to use this theory.Common CommandsIt would be a good time to define some custom commands that make using Plover much easier! Just open the add translation dialog, then enter in the steno you want to use to make the command, and enter the following as translation:{PLOVER:ADD_TRANSLATION}this will let you use a chord to summon the add translation dialog{-|}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-split-at-apostrophe
Plover Split at ApostropheCompanion plugin for BépoSténo - split words at the apostrophe key.The premise:For certain languages, articles that go placed before a noun or adjective that starts with a vowel (eg.le appétit) can get contracted (intol'appétit).
This means that contracting an expression likel'appétitwould take the steno strokes fromL{apostropheKey}/A/PE/TI(pronouncedle appétit) toL{apostropheKey}A/PE/TI. Given that french and italian are full of these little contractions, it would save a lot of keystrokes to be able to have contracted articlesandvowel-starting words into a single stroke. A few more examples:L{apostropheKey}An:l'an(tr: the year)J{apostropheKey}A/T*Or:j'adorefunctionality:Having apostrophe-separated strokes assumes the following:The apostrophe-key must act as a word-boundary at its position in the steno-order. Using my current steno-order:S K P M T F * R N L {apostropheKey} Y O ^ E È A À U I l É n $ B D C # ß- any stroke following the pattern:[SKPMTFRNL]{apostropheKey}[YO^EÈAÀUIlÉn$BDC#ß]would be interpreted by plover as[SKPMTFRNL]{apostropheKey}{^}[YO^EÈAÀUIlÉn$BDC#ß].The strokes on the left-side of the apostrophe-key terminate a word, the ones on the right-side start a new one.Plover needs a notation to represent the keys on either side of the apostrophe-key as strokes. This is similar to the current way of handling conditionals that plover has ({=REGEXP/TRANSLATION_IF_MATCH/TRANSLATION_IF_NOT}) - with the notable difference that capture groups from the=REGEXPwould have to be re-usable in theTRANSLATION_IF_MATCH.UsageChoose a key to be your apostrophe key. Set it in yoursystem.pyin the steno order. In most syllabic steno systems, such as GrandJean, that would be after the attack consonants, and before the vowels.
From there, any stroke that you want to split at the apostrophe key needs to call the plugin, using the following format in the dictionnary:"<start_of_stroke><apostrophe_key><rest_of_stroke>": "=split_word_at_apostrophe",This is less than ideal, as it forces the user to write up every stroke that will have to be split into to the dictionnary. Luckily though, I've found through experience that there are not so many strokes that will require this.
Package: plover-sqlite-dictionary
plover-sqlite-dictionarySQLite-based dictionary format for Plover. Consumes less memory for large dictionaries.Why?Reduce memory (RAM) consumption.  (however, the word list for orthography
suffix rules and Qt modules still take a considerable amount of RAM)Faster loading/startup speed.NoteThe SQL dictionary format is not completely compatible with Plover's API specification,
the plugin may fail to work properly in future Plover versions.UsageThere are two possible file formats:SQLite-based:.sqlextension.Use the "New dictionary" feature in Plover to create one, or "Save dictionary as..." feature
to convert from other dictionary formats.Note:If there's a table namedreadonly(the content doesn't matter), the dictionary will be
considered read-only.Because ofa Plover bug, modifying the
dictionary file and reloading the dictionary in Plover might not update the read-only status.The file size is larger than the size of a JSON dictionary.When an entry in the file on the disk is changed, it's automatically updated into Plover.When the dictionary is deleted on disk, attempt to modify the dictionary in Plover
will cause "attempt to write a readonly database" error; otherwise, the dictionary remains usable.It's possible to have additional columns for auxiliary entries if:There's no attempt to modify the dictionary, orAll the additional columns have default values set (or default to null).JSON: stored as plain JSON file on disk..jssqlextension.Note: This format takes longer to load than normal JSON dictionary.Can be used like a normal Plover dictionary.
Package: plover-startup-py
plover-startup-pyQuick and dirty plugin to run something when Plover starts.About pluginThis plugin should only used for testing purposes. See also:user202729/plover-debugging-console: A IPython debugging console for Plover.user202729/plover-run-py: Command plugin for Plover to run an arbitrary Python command.Disadvantages in comparison to writing an extension plugin:Can only be used on a single machine.However, it should not be hard to convert a configuration file into an extension plugin to be distributed.Advantages over writing an extension plugin:For testing purposes, the user-provided code might have some bug/errors.While using a normal extension plugin might make Plover nonfunctional (for example ifstop()raises
an error, Plover quit will be interrupted), this module guarantees that Plover is never interrupted.Has a reload command, which is faster than restarting Plover.Some convenience functions to make hacks easier to achieve.InstallationThe package can be installed from pip or GitHub.ConfigurationYou need to create a file namedplover_startup_py_config.pyin Plover's configuration folder
(seehttps://plover.readthedocs.io/en/latest/api/oslayer_config.html#plover.oslayer.config.CONFIG_DIRfor where it is exactly)The file may define (and register) functionsstartandstop:@register_startdefstart():pass@register_stopdefstop():passThey will be called when the plugin starts/stops (which is normally when Plover starts/exits)The engine can be accessed as the global variableengine, and there are more convenience functions,
search for "convenience functions" in the source code for more details
(and to read their documentation).The last line inload_file()function inplover_startup_py/__init__.pyfile
have the complete list of global variables passed to the configuration file.UsageGo to "Plugins" tab of Plover configuration, enable the plugin named "plover_startup_py".To view the full traceback/error messages, you may need to invoke Plover with--log-level debug.There's also an additional command{plover:plover_startup_py_reload}for reloading the module.
Package: plover-start-words
Plover Start wordsThis plugin provides a meta for Plover, so we can choose the output produced deppending on the last typed text.Usage# initial.json
{
"STROke": "{:initial:textStartingNextWord | textFollowingPreviousFragment}"

...
}APIAPI can be manipulated viaPython dictionaries.For example:# single.py
from plover_start_words import meta

meta.prefixes = ("", "foo", "var")

LONGEST_KEY = 1


def lookup(key):
	raise KeyErrorVersioningWe useSemVer.ChangesChangelog
Package: plover-stenobee
StenoBeePlover plugin for Spelling Based StenographyCreated by Tink & Emily & KaoffieWith lots of help from, Jen and paulfioravanti :)StenoBee, is a spelling based, orderless Steno theory for Plover.Some key points about StenobeeOriginally started, to address issues arising from local dialect differences.Comes with a default dictionary of 13k unique words from my own posts, plus around 8k phrases taken from ngram data.You can also make your dictionary from your own word list/raw text (using the tools at the bottom of the page)What is StenoBee is bad at.Captioning, and court reporting work, since the orderless non phonetic nature of it actively makes transcription related work harder.Ambiguity with some shorter words, some memorization may be needed.Some things that StenoBee is Good forCan be easily customized using tools provided at the very bottom.It's great at encoding long words and phrases into single strokes.IF you are here, and you are still interested.You can also make the dictionary entirely based on what you want.Using these tools, you can take either raw text, or a ranked list.Then make a common words dictionary from it.Tools to filter and clean raw text, and turn it into 3 lists for easier handling.https://www.dropbox.com/scl/fi/0p09wxwk1vsha8tgkgi1q/Raw-text-to-List-Tools.zip?rlkey=dem74k15jicj63ir33hn0l51g&dl=0Tools to take your tex, and convert it into the dictionary file, replacing the "common" dictionary file.https://www.dropbox.com/scl/fi/dfnrg4mn40s8mrj70d89y/List-to-Common-Json-Tools.zip?rlkey=zdx6ze8z8pg63ea26yqt9m7fg&dl=0An alternative Ergo centric number layout.
Package: plover-stenograph
Plover StenographA Plover plugin for using newer Stenograph machines (Stentura Protégé and
Fusion, Élan Mira and Cybra, Diamanté, Wave, Luminex) connected to the computer
over USB or Wi-Fi.This is a work-in-progress rewrite of theplover-stenograph-usbandplover-stenograph-wifiplugins to reuse code and add more protocol functionality.
Package: plover-stenograph-usb
Use Stenograph machines such as the Luminex, Diamanté, and Protégé on Plover. The plugin may
not work with other machines.Special thanks to Keith McCready for his guidance and support.Tested MachinesIf you test another machine, please let me know whether it works or not.Working
- Luminex
- Diamanté
- ProtégéNot Working
- UnknownGet the DriversOn Windows, install theStenograph USB Drivers(direct link)On Mac and Linux, the plugin should work without additional software as we package libusbInstallationThe plugin is available to install from within Plover 4 using the
Plugins Manager.Changelogv1.2.1:Compatibility with newer versions of python/ploverv1.2.0:Package libusb to remove the need to install it on Mac and Linuxv1.1.0:Reduce CPU usageFix support for 64-bit Windows