Saravanan666/pypi-org huggingface dataset:
Package: vimiv
website|docs|install|screenshots|changelog|contributing:information_source: This Qt port is the future of vimiv. New features will
only be implemented here and there are already many improvements compared to thedeprecated gtk version. The old version is only
recommended if you require a more stable software. In case there is anything you miss
here, pleaseopen an issue. Check theroadmapfor more details.Vimiv is an image viewer with vim-like keybindings. It is written in python3
using the Qt5 toolkit and is free software, licensed under the GPL.FeaturesBasic image operations and navigationranger-like library to browse your imagesThumbnail mode: navigable grid of image previewsCommand mode with tab-completionSearch with pattern matchingSimple mark and tag systemCustomization of keybindings, settings and style via configuration files,base-16 support, ...InstallTo learn how to get vimiv running on various platforms, please check out theinstallation guide.DocumentationMuch more details on vimiv are available on thewebsite. Here are some hints to get you started:The installation guideincludes instructions on how to get vimiv running on various platforms.Getting startedstarts with the basic concepts and keybindings to later show some more advanced
features.Commandsgives a complete overview and description of all commands.Keybindingslists the default keybindings and describes how to configure them.Settingsdescribes the available settings and how to change them.Styleexplains how to configure the look and colorscheme of vimiv.Pluginsillustrates vimiv's python plugin system: a great way to extend the functionality
beyond the defaults and to start delving into the source code.ContributingYou want to contribute to vimiv? Great! :tada:Every little help counts and is appreciated!  Feel free to read thecontributing guidelinesfor some useful tips and tricks.There are many ways to contribute, including:giving feedback and requesting new featuresreporting bugswriting codeextending the documentationspreading the word in an article, blog, reddit post, ...Need help? Feel free tocontact me directlyor, even better,
open anissue on github.LicenseThis program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later
version.This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.You should have received a copy of the GNU General Public License along with
this program. If not, seehttp://www.gnu.org/licenses/.
Package: vimlib
A friendly interface for interacting with Vim using Python.Installationpip install vimlibRecommended: Using your chosen virtual environment, that's been setup for
Vim, or Neovim, to use, installvimlibusing that.Examples:~/vimfiles/.venv/bin/pip.exe install --upgrade vimlibcd ~/vimfiles && poetry install vimlibUsageCurrentvimliboffers a convenient way to interact with the current environment, much
like Vim's built-in current object.frompyvimimportcurrentEchovimliboffers a convenient way to print to Vim's stdout in a colorful, and
flexible, manner.importpyvim# Print to STDOUTpyvim.echo("Hello!")# Print with chosen highlight grouppyvim.echo("Hello!","PyVimSuccess")# Built-In Greenpyvim.echo("Hello!","PyVimCaution")# Built-In Yellowpyvim.echo("Hello!","PyVimDanger")# Built-In RedHighlight Groupsvimliboffers a convenient way to interact with highlight groups.frompyvimimportcurrent# Boolean. Check if a highlight group is availablehas_highlight='MyHighlightGroup'inpyvim.current.highlightsVisual Selectionvimliboffers a convenient way to interact with highlighted text. Also
highlights the most recent highlighted text.frompyvimimportcurrent# String with the current, or last, selection.# Support basic, linewise, and block visual highlightsselection=pyvim.current.selectionUtilitiesvimliboffers convenient utilities.System CommandsNote: Chaining will stack<CR>and other tokens.frompyvim.utilitiesimportwrap_vim_commandwrapped_command:str=wrap_vim_command(command="!py %",silent=True,clear=True,)print(wrapped_command)# ":<C-U>silent !py %<CR>Examples>>>print(wrap_vim_command('w')):<C-u>w<CR>>>>print(wrap_vim_command('w!',silent=True)):<C-u>silentw!<CR>Mappingsvimliboffers a convenient way to interact Vim mappings.>>>importpyvim>>>>>>>>># Set <Leader>r to write current buffer to disk.>>># Equivalent to `:nmap <Leader>r :<C-u>silent w<CR>` in Vim.>>>set_mapping('nmap','<Leader>r',':<C-u>silent w<CR>')FunctionWARNING: Non-Workingvimliboffers a convenient way to interact Vim functions.importpyvimvim_function=pyvim.Function(name="Foo",arguments=None,optional_arguments=True,overwrite=True,)result=vim_function(...)JobWARNING: Non-Workingvimliboffers a convenient way to interact Vim jobs and channels.importpyvimvim_job=pyvim.Job(cmd='python -m http.server',)vim_job.stop()vim_job.statusRegistersvimliboffers a convenient way to interact Vim registers.>>>importpyvim.Register
Package: vimmock
vimmockvimmock is a module that makes testing Python code usingvimmodule much
easier.UsageAt the test environment initialization one should preparevimobject that
would normaly be used within vim’s plugin. We have added convenient function for
that:import vimmock
vimmock.patch_vim()This is equivalent to:import sys
from vimmock import VimMock

sys.modules['vim'] = VimMock()Once this is done one can start importingvimmodule which would be instance
ofVimMockclass. From now on we can write our tests (and importvimmodule):import vim
import unittest
import myplugin

class TestPlugin(unittest.TestCase):

    def setUp(self):
        vim.setup_text('\n'.join(('foo', 'bar')))

    def test_simple(self):
        vim.current.window.cursor = 2, 0 # rows starts from 1, column from 0
        # ... let's assume our plugin swaps lines
        self.assertEqual(vim.current.buffer[0], 'bar')
        self.assertEqual(vim.current.buffer[1], 'foo')DevelopmentPlease use github’s issue tracker for filing new issues. Preferred way of
attaching patches is viapull requests.Work in progressPlease note thatvimmockis a work-in-progress module. Only basic mocks are
actually completed. If you want to use this module for now it is best if you
fork it, link to yourPYTHONPATHenvironment variable and modify on the fly.
Pull requests are welcome!
Package: vimms
AboutLiquid-Chromatography (LC) coupled with tandem mass spectrometry (MS/MS) is a prevalent technique for identifying small molecules in untargeted metabolomics. There are various strategies for acquiring MS/MS fragmentation spectra, but devising new methods is often challenging due to the absence of a structured environment where researchers can prototype, compare, and optimize strategies before testing on real equipment.To solve this, we introduce theVirtualMetabolomicsMassSpectrometer (VIMMS), a flexible and modular framework designed to simulate fragmentation strategies in tandem mass spectrometry-based metabolomics.Quick Start & DocumentationEager to start using ViMMS? Take advantage of these resources:Installation guide.Visit our project documentation page:OurDemo foldercontains notebooks that demonstrate how to use the framework in a simulated environment.For specific examples that accompany our publications, see theExample folder.You can also find thisquick guide on how to get started using ViMMS.Key FeaturesViMMS provides scan-level control simulation of the MS2 acquisition process in a virtual environment. You can generate new LC-MS/MS data based on empirical data or virtually replay a previous LC-MS/MS analysis using existing data, which allows for testing different fragmentation strategies. With ViMMS, you can evaluate diverse fragmentation strategies using real data, and extract the scan results as mzML files.Moreover, ViMMS serves as a platform for the development, optimization, and testing of new fragmentation strategies. These strategies can be implemented by extending a Controller class in ViMMS, and can be tested on both the simulator and actual mass spectrometry instruments that support compatible APIs.To see a more thorough explanation of the use cases of ViMMS, please refer to theUse Casessection.ContributionsAs an open-source project licensed under MIT, we welcomes all forms of contributions, including bug fixes, new features, and more. You can find our community contribution guidelineshere.Citing ViMMSTo cite ViMMS or read about the list of publications that are built on top of ViMMS, please refer to thePublicationspage.
ViMMS is also activelypresentedin various computational biology venues.
Package: vim-pck
A command-line tool to manage my vim plugins using the built-in package
feature of vim8. (see :help packages)Table of contents:Dependencies;Installation;How to use;Related projects;Note;License.Dependenciesgitpython 3.6InstallationI like to install python command line programs in their own virtual
environment to not clutter the system wide package directory.pipsimake it very conveniant to do so by automatically creating the venv and
symlinking scripts to~/.local/bin. If you don’t usepipsi,
you’re missing out. Here areinstallation
instructions.Simply run:$pipsiinstallvim-pckAlternatively, with pip:$pipinstallvim-pckHow to useConfiguration fileThe main configuration file where the vim packages are specified. It’s
default location follow theXDG specificationthat is$XDG_HOME_CONFIG/vimpck/configor~/.config/vimpck/configifXDG_HOME_CONFIGis not set.[SETTING]# The built in package directory. See :help packagespack_path=~/.vim/pack# pack_path= ~/.local/share/nvim/site/pack for neovim[REPOSITORY][[https://github.com/tpope/vim-commentary]]package=commontype=startfreeze=True# Don't update vim-commentary when launching vimpck upgrade[[https://github.com/tpope/vim-dispatch]]# default location pack_path/vimpck/start/vim-dispatch[[https://github.com/mustache/vim-mustache-handlebars]]package=filetypetype=start[[https://github.com/altercation/vim-colors-solarized]]package=colorstype=startThen runvimpck installto clone each remote repository in the
correct package location. For exemple,vim-commentary–>~/.vim/pack/common/start/vim-commentaryFor neovim the package path should be set to~/.local/share/nvim/site/packOptiondefault valuepack_path~/.vim/packpackagevimpcktypestartfreezeFalseUsageTo use it (seevimpck--help):$ vimpck install: install plugins from the configuration file$ vimpck ls: list all plugins$ vimpck ls--start: list plugins that are automatically loaded$ vimpck ls--opt: list plugins that have to be loaded manually$ vimpck upgrade: update all plugins that are not freezed$ vimpck upgrade<plug>...: only update<plug>plugin. The
plugin have to be specified using the following patternpackage/type/plugin. You can easily complete the<plug>with
the zsh completion script.vimpck rm<plug>...: remove one or more<plug>. Support zsh
completion.vimpck rm-r<plug>...: remove one or more<plug>and also
remove the corresponding section from the configuration file.vimpck clean: remove unused pluginsEnvironment variableVIMPCKRC: override default configuration location (xdg standard)Example :exportVIMPCKRC=/path/to/conf/nameCompletionA zsh completion function is provided in thecompletionfolder of
this repository.To use it copy_vimpcksomewhere in the$fpathenvironment
variable of zsh and make sure the completion module of zsh is loaded by
putting these following lines in your.zshrc:autoload-UcompinitcompinitRelated projectsminpac: vim plugininfect: command-line tool
build in ruby.pack: command-line tool build
in rust.vim8-pack: command-line
tool in bash.NoteProject generated withcookiecutter-python-cliLicenseMIT license, see the LICENSE file. You can use obfuscator in open source
projects and commercial products.
Package: vimpdbhook
Using this package one can enable a hook in the python pdb
such that the current file is automagically opened in MacVim
and the line is highlighted.FeaturesActivates MacVIM, uses new tab to open debugged filereuses existing MacVIM instanceafter loading the file, the terminal program is activated
(given focus) to allow for rodent-free debugging.The focus-switching is done usingappscriptwhich is a python
package for AppleScript.DependenciesMac OS X (duh)MacVim (or another gui-enabled VIM which understands the
VIM server commands – currently only MacVIM)Usageinstall this packageput something like this in your~/.pdbrc:# save this in .pdbrc in your home directory
from vimpdbhook import preloop, precmd
pdb.Pdb.preloop = preloop
pdb.Pdb.precmd = precmdmake sure that you have also installed themvimcommand line
utility for firing up macVIM using the terminal.Currently, I assume that you use “iTerm” and use a variant ofmvimcalledvimpdb(that’s my setup).  Please see below.TweakingThe package uses the environment to fetch the name of the terminal app and the
MacVIM launch scriptVIMPDBHOOK_MVIM_SCRIPTSet this to yourmvimscript. default:vimpdbVIMPDBHOOK_TERMINAL_APPSet this to the name of the terminal application. default:iTermLinksMacVimhttp://code.google.com/p/macvim/iTermhttp://iterm.sourceforge.net/Download
Package: vim-plugins-profiler
VIM PLUGINS PROFILERvim-plugins-profileris a small utility which outputs a sorted list ofvim
editorplugin startup times in millisec. Only vim
plugins you have installed personally in your home directory are
considered. This utility was written for Linux platforms but should work
on other platforms as well, including Mac and Windows.The latest version and documentation is available athttps://github.com/bulletmark/vim-plugins-profiler.Just run at command line, e.g.:$ vim-plugins-profiler
   1:    16.759 (54.4%) nerdtree
   2:     4.248 (13.8%) vim-airline
   3:     2.880 ( 9.3%) delimitMate
   4:     2.000 ( 6.5%) tabular
   5:     1.596 ( 5.2%) emmet-vim
   6:     1.579 ( 5.1%) YouCompleteMe
   7:     0.668 ( 2.2%) ctrlp.vim
   8:     0.399 ( 1.3%) vim-surround
   9:     0.271 ( 0.9%) vim-better-whitespace
  10:     0.155 ( 0.5%) vim-commentary
  11:     0.141 ( 0.5%) autoload_cscope.vim
  12:     0.080 ( 0.3%) ag.vim
  13:     0.034 ( 0.1%) vim-javascript
  14:     0.015 ( 0.0%) typescript-vim
  15:     0.010 ( 0.0%) vim-vueThe plugin startup times are in millisec, sorted from highest usage to
lowest.The percentages are the percent of total plugin startup time
(i.e. the total plugin time additional to normal vim startup time)
that each plugin contributes.You should also be able to use it withneovim:$ vim-plugins-profiler -e nvimUSAGETypevim-plugins-profiler -hto view the usage summary:usage: vim-plugins-profiler [-h] [-e EXE] [-r RUNS] [-n NUM]

Output sorted summary of VIM plugin startup times in millisecs.

options:
  -h, --help            show this help message and exit
  -e EXE, --exe EXE     vim executable name or path, default="vim"
  -r RUNS, --runs RUNS  number of sample runs to average over, default=4
  -n NUM, --num NUM     limit output to given number of pluginsINSTALLATIONNOTE: Arch Linux users can just installvim-plugins-profiler from the AUR.Python 3.6 or later is required. Notevim-plugins-profiler is on
PyPIso just ensure
thatpipxis installed then type the
following:$ pipx install vim-plugins-profilerTo upgrade:$ pipx upgrade vim-plugins-profilerLICENSECopyright (C) 2018 Mark Blakeney. This program is distributed under the
terms of the GNU General Public License. This program is free software:
you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation,
either version 3 of the License, or any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License athttps://www.gnu.org/licenses/for more details.
Package: vim-plugin-starter-kit
Get productive a little fasterI created the vim-plugin-starter-kit to help speed up development and
perhaps shorten the learning curve involved with writing Vim plugins.Installationpip installvim-plugin-starter-kitUsageRunvim-plugin-starter-kitfrom the command line. Once you answer a
few questions you will have all that you need to immediately get started
writing a new Vim plugin with the Python language. The resulting
directory will contain scaffolding for documentation, testing, and your
.py and .vim files customized for your specified project name. The files
will contain working examples you can use as reference as you begin
writing your plugin.WikiAs you’re are getting started check out theWikifor more examples of usage of common interactions between Python scripts with
the Vim buffer.But Wait There Is MoreEver wonder how to get started writing your own vim plugin? I gave a
talk where I use the starter-kit and walk through step by step writing
and testing a complete plugin. Check it outhere
Package: vim-quest-cli
VimQuestCLIThis is a vim implementation in python that tries to implement game using the vim shortcuts.Why python ?I love python. Maybe one day it's going to be converted in Rust (for easy webassembly and faster execution). But for now it's python 3.8.Choice when doing executionsExecutor :local (the python vim implementation)vim (calling vim to execute stuff, for compatibility tests)Terminal handling :Curses wrapper : the way it's usually done in python.
It allows for curses to catch the input."manual" curses : Without using the full curses capabilities.Execution loop :One method to start the whole loop.One method that have the input as argument and returns what to print.The python version doesn't have just vim capabilities, but allows to expand for allowing for hooks and data attached to the cells.TodoSeparate presentation layerAdd a vim executor (to be able to compare tests).Have a context that is not a copy but modify itself (for speed).Have a bunch of hooks, and use them to have game modes.Have a command to choose between game modes.See how neovim is made so I can use the same architecture.Maybe have syntax highliting for game modes too ?Activate the UTF-8, see how I can activate it.Create docker images for website and terminal.Add git hook for cleaning python before commit.Use unicode characters (not necesseraly emojii) with colors for differents things happening.BUG CORRECTION :Clean codebase.ANSI is blinking.Image location is not working.Size of the terminal is not used.Unicode block behavior is inconsistent.Maybe having replacement for unicode that include colors.Referencesvim-adventures.com: really cool game. I keep paying for it as the licence is only for 6 months.vim.so: Manual tests using a modified javascript editor.vimgenius.comgithub.com/iggredible/Learn-VimPython prompt toolking has a python implementation of vi commands :https://github.com/prompt-toolkit/python-prompt-toolkit/blob/master/src/prompt_toolkit/key_binding/bindings/vi.pyNow vim implementationthat I could use for corectness :ace js :https://github.com/ajaxorg/ace/blob/master/src/keyboard/vim_test.jsideavim :https://github.com/JetBrains/ideavim/tree/master/src/test/java/org/jetbrains/plugins/ideavimncurses implementation :https://github.com/mscdex/node-ncursesMaybe this implementation would be easier to understand than the c ncurses one.Next steps to coverhjkl x[number]commandiaAddwbev, Shift-vypP"ci"Next step.Vim core. That execute the commands and return a status. From a Contains the screen size andVim window. That take that buffer and return a screen. (matrix of data points with metadata).Attachable are game modes.Then there is terminal that push characters and returns aUse an alternate screen :https://stackoverflow.com/questions/11023929/using-the-alternate-screen-in-a-bash-scriptFor inspiration :NethackAdd keystroker counts for speed.
Info box to see what's happening in the game.Game ideas :Enemies coming at you and you have to delete the terrain that is underneath them without running out of terrain yourself. But if they touch you, you're dead and has to restart the game.
Package: vimrunner
VimrunnerModule that implements a client and server interface useful for controlling a
Vim editor, started as a server, programmatically. This module could be used
for unit testing or integration testing for a Vim plugin written in Python.
Or you can use it to interactively control a Vim editor by python code, for
example, in an Ipython session.How it all startedI created a class that used thevim python moduleto emulate a vim buffer and that would act like a list, so you could read and
write lines and manipulate text using python.However, I stumbled acrossVimrunnerwhich is a Ruby gem used to “spawn a Vim instance and control it
programatically.”So, this python module is heavily inspired by the project mentioned above.InstallationThere is avimrunner packageon
PyPI, so you can install it with:pip install vimrunnerAlternatively, you can just drop vimrunner.py file into your project - it is
self-contained.TestingYou can run unit tests using the command:python setup.py testUsageimportvimrunner# initialize vim servervim=vimrunner.Server()# start GVIM as server and get a client connected to itclient=vim.start_gvim()client.edit('any_file')client.source('path/to/vim/plugin')# start Vim editor in a terminal; it should work for Debian, Ubuntu, etc.# that have a desktop installedclient=vim.start_in_other_terminal()Documentation is available athttp://andri-ch.readthedocs.org/en/latest/For any suggestions regarding the module and its documentation, please submit
an issue usingGitHub issue tracker
Package: vimtips
Vim TipsIntroductionVim Tipsis a project to aggregate and show vim tips from different sources. A small daemon waits for screen unlocks
and automatically starts the vim tips gui if it is the first unlock of the day.InstallationVim Tipscan be installed withpipon Linux and macos:python3-mpipinstallvimtipsVim tipscontains components that must be compiled on installation, so ensure you have XCode installed on macos or
build tools on any Linux distribution. For Linux, you also need X11 headers. On Ubuntu / Debian-based distributions you
can install these dependencies with:aptinstallbuild-essentiallibx11-devnx-x11proto-xext-devIf you run an Arch-bases system, you can also installvimtipsfrom theAUR:yay-SvimtipsUsageAfter installation, you get the new commandsvimtips-guiandvimtips-daemonto start the graphical application or
the daemon process. On the first gui start, the cache of vim tips is refreshed so the first startup can take several
seconds. Future runs renew the cache in the background. You can addvimtips-daemonto your startup / login items to
automatically get new tips on computer startup or when you unlock the screen for the first time of the day.Login item creation on macosIt is indeed possible to add terminal commands to the user's login items but this will cause the startup of a terminal
window every time you login to your Mac. A better solution is to start the preinstalledAutomatorapplication, create
a new app and add a bash script which startsvimtips-daemon. The created app can then be added to hidden login items.Tip sourcesCurrently, only twitter is supported as a tip source (thevimtips,VImTipsDaily,vimpalandVimTipaccounts are read) but new sources can be added by creating a new Python
module invimtips/sources. Look atvimtips/sources/twitter.pyfor an example. You only need to implement a global functiontipswhich returns a list of strings.Screen unlock detectionThis package has different backends to detect a screen unlock and automatically chooses an appropriate one:Linux:xscreensaver: Ifxscreensaveris running, it will be asked for unlock events.gnome-screensaverandxfce4-screensaver: Can also be asked for unlock events.X11 dpms: As a fallback, dpms events are watched which should work on every Linux desktop. However, this backend
does not really check for a screen unlock, it checks the screen power state instead (however, in most configurations
the screen is sent to sleep when the screen is locked, so this should be fine on most systems). This backend could
fail if screensavers are used.macos:On macos, the screen power state is watched similar to the Linux X11 backend. If anyone knows how to check for a
screen lock, please send a pull request! :)