Saravanan666/pypi-org huggingface dataset:
Package: 2dxPlay
2dxPlayPlay konami 2dx files from the command line.Install with pip and run it from anywhere.pip install 2dxPlayUsage:2dxplay infile.2dxIf the file contains more than one wav, it will play all tracks sequentially.Press Ctrl+C to pause and enter a track number to jump to, orqto quit.###Tip: Play any 2dx file just by double clicking on it:
Right click on a 2dx file, choose Open With > Look for another app on this PC.Navigate to your python installation where 2dxPlay.exe is installed. (I use python 3.7, so pip
installed it in%appdata%\Local\Programs\Python\Python37\Scripts).Check the "Always use this app" box and profit.
Package: 2fas
2fas Python2fas-python is an unofficial implementation
of2FAS - the Internet’s favorite open-source two-factor authenticator.
It consists of a core library in Python and a CLI tool.InstallationTo install this project, use pip or pipx:pipinstall2fas# or:pipxinstall2fasUsageTo see all available options, you can run:2fas--helpIf you simply run2fasor2fas /path/to/file.2fas, an interactive menu will show up.
If you only want a specific TOTP code, you can run2fas <service>or2fas /path/to/file.2fas <service>.
Multiple services can be specified:2fas <service1> <service2> [/path/to/file.2fas].
Fuzzy matching is applied to (hopefully) catch some typo's.
You can run2fas --allto generate codes for all TOTP in your.2fasfile.Settings# see all settings:2fas--settings# shortcut: -s# see a specific setting:2fas--settingkey# update a setting:2fas--settingkeyvalueThe--settings,--settingor-sflag can be used to read/write settings.
This can also be done from within the interactive menu.As a LibraryPlease see the documentation oflib2fas-pythonfor more details on
using this as a Python library.LicenseThis project is licensed under the MIT License.
Package: 2Keys
# 2Keys
A easy to setup second keyboard, designed for everyone.For a full setup guide, see [here](https://github.com/Gum-Joe/2Keys/blob/master/docs/SETUP.md)For keyboard mappings, see [here](https://github.com/Gum-Joe/2Keys/blob/master/docs/MAPPINGS.md)### Support
Windows is supported only as the server (where the hotkeys will run) and a raspberry pi is required to run the detector.## WARNING
This will download a copy of [AutoHotkey_H](https://hotkeyit.github.io/v2/), a DLL version of [AutoHotkey](http://autohotkey.com/)## Building
To build the server, where hotkeys are run:` $ cd server $ yarn `To build the detector:` $ cd detector $ pip3 install-rrequired.txt `## DevicesServer: The device running the hotkeys sever, i.e. where the hot keys will be runDetecter: Device that handles detection of key presses & which keyboard it is and sends this to the server## Sofware used & inspiration
Inspired by LTT editor Taran’s second keyboard project: [https://github.com/TaranVH/2nd-keyboard](https://github.com/TaranVH/2nd-keyboard)2Keys uses AutoHotkey_H (a DLL version of AutoHotkey): [https://hotkeyit.github.io/v2/](https://hotkeyit.github.io/v2/)## License
Copyright 2018 Kishan Sambhi2Keys 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.2Keys 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 2Keys.  If not, see <https://www.gnu.org/licenses/>.
Package: 2lazy2rest
A simple way to produce short-to-medium document usingreStructuredTextMulti-format themesRender the same document in HTML, ODT, PDF keeping the main visual identityUnified interfaceTired of switching between rst2* tools having different arguments or behavior ?Would like to not losecode-blocksor some rendering options switching the output format ?This tool try to address thisMake your own themeTODO: templates will be customizable easily (say, probably colors only)How to use itDependenciesYou’ll needrst2pdfto use all the features, other rst2* tools are coming from docutils.Usingmkrst [-h] [--html] [--pdf] [--odt] [--theme THEME]
             [--themes-dir THEMES_DIR]
             FILEoptional arguments:-h,--helpshow this help message and exit--htmlGenerate HTML output--pdfGenerate PDF output--odtGenerate ODT output--themeTHEMEUse a different theme--themes-dirTHEMES_DIRChange the folder searched for themepopo:~/2lazy2rest%./mkrsttest_page.rst--html--pdfUsing ./themes/default
  html:  test_page.html
   pdf:  test_page.pdfCustomizingMake a copy ofthemes/default, edit to your needs the copy and use the–themeoption with the name of your copy, that’s All !Examplepopo:~/2lazy2rest%cp-rthemes/defaultthemes/redpopo:~/2lazy2rest%sed-si's/#FEFEFE/red/g'themes/red/html/stylesheet.csspopo:~/2lazy2rest%./mkrsttest_page.rst--html--themeredIssuesODT style is unfinishedPDF & HTML still needs more ReST coverageNo skin generation from template yet
Package: 2ppy
2PPy (tuProlog in Python)Experimental porting of2P-Kton Python, viaJPype.This is awork in progress. 2PPy is not ready for general availability, yet.IntroductionObject-oriented and modular ecosystem for symbolic AI and logic programming, currently featuring:a module for logic terms and clauses representation, namelytuprolog.core,a module for logic unification, namelytuprolog.unify,a module for in-memory indexing and storing logic theories, as well as other sorts of collections of logic clauses, namelytuprolog.theory,a module providing generic API for resolution of logic queries, namelytuprolog.solve, currently implementing a Prolog solvertwo parsing modules: one aimed at parsing terms, namelytuprolog.core.parsing, and the other aimed at parsing theories, namelytuprolog.theory.parsing,two serialisation-related modules: one aimed at (de)serialising terms and clauses, namelytuprolog.core.serialize, and the
other aimed at  (de)serialising terms theories, namelytuprolog.theory.serialize,a module for using Prolog via a command-line interface, namelytuprolog.repl.How to do stuffPrerequisitesInstall Python 3 (look into the.python-versionto know the exact version)I suggest usingPyenvto easily handle multiple Python versions on the same machineEnsure PIP works fineInstall Java (JDK preferred), andensure theJAVA_HOMEvariable is correctly setEnsure Java and Python are both either 64bit or 32bitIf you have installed some prior development version of 2PPy (e.g.tuppyortuprolog), uninstall them viapipuninstalltuppytuprologOnMac OSthis may not work as expected.
Consider running the following command instead:python3-mpipuninstalltuppytuprologHow to develop 2PPyRestore Python dependencies via PIP, by running:pipinstall-rrequirements.txtOnMac OSthis may not work as expected.
Consider running the following command instead:python3-mpip-rrequirements.txtRestore JVM dependencies viadownload-jars.sh, by running:./download-jars.shNotice that this command requirescurlandwgetto be installed on your system (wgetmay be lacking onMac OSand Windows)How to use 2PPy as a libraryInstall 2PPy from Pypi by running:pipinstall2ppyOnMac OSthis may not work as expected.
Consider running the following command instead:python3-mpipinstall2ppyImporttuprolog.*modules in your Python scriptsProfitHow to use 2PPy as an executableInstall 2PPy from Pypi by running:pipinstall2ppyOnMac OSthis may not work as expected.
Consider running the following command instead:python3-mpipinstall2ppyRuntuprologmodule viapython-mtuprologFor the moment, running 2PPy means starting an interactive Python shell with pre-loadedtuprolog.*modules.Eventuallypython -m tuprologwill launch a command-line logic solver.
Package: 2us
__ (Double Underscores, 2us)Glueing functionals byimport __for python!InstallThe package is written in pure python, with no dependencies other than the Python language. Just do:pipinstall2usRequires Python 3.5 or higher.Why this?Python is a great language for creating convenient wrappers around native code and implementing simple, human-friendly functions.
In python, a bunch of builtin higher-order methods (which means that they accept functions as arguments) such asmap,filterare available.
They enable streamed data processing on containers that focus on the processing itself,
in contrast withnoisy codeon traditional command-based languages that is heavily involved in loops.However, you may occasionally run into the situatiion where you find that there is no standard library functions to implement in-line unpacking of tuples,
adding all numbers in a list by a constant shift, so you will have to write:map(lambdax:x+1,some_list)map(lambdax:x[0],some_list)which seems rather dumb due to the inconvenient definition of lambda functions in python.Using __Start using the package by importing__:import__And then__can be used to create convenient functions that are identical to those written withlambda. Examples:assertsum(map(__+1,range(1000)))==sum(map(lambdax:x+1,range(1000)))assertset(map(__[0],{1:2,4:6}.items()))=={1,4}assertfunctools.reduce(__+__,range(1000))==sum(range(1000))Currently there is a drawback: python do not support overriding__contains__returning non-boolean values, so theincondition should be handled separately.asserttuple(map(__.is_in([1,2]),[3,1,5,0,2]))==(False,True,False,False,True)assertlist(map(__.contains('1'),'13'))==[True,False]
Package: 2xh-leet
LEETLibrary of Eclectic Experiments by TenchiRandom modules that I made and use in several project and are too small to get their own package. Autillibrary of sorts.ContentsLoggingProgress barsImagesLoggingModule that provides a fancy-looking theme for Python loggers.(TODO: Screenshot)To enable,import leet.loggingfrom anywhere (maybe the main__init__.pyof your project). You will then have a global loggerlogfunction that you can use from anywhere:log.info("Hello")log.warn("World")If using MyPy (or if you don't like monkeypatching) you can import the logger explicitly in each module as needed:fromleet.loggingimportloglog.info("Explicit import")Progress barsAlso provides a progress bar (fromWoLpH/python-progressbar) that fits in the theme:fromtimeimportsleepfromleet.loggingimportlog_progressforiinlog_progress.debug(range(10)):sleep(1)log.info("Working on%d..."%i)ImagesAlso supports outputing images viaimgcatif usingiTerm2(support for other tools pending):log.warn("Image is too big:",extras={"img":"path/to/image.png"})
Package: 31
3131 is a simple tool you can use to run code in the background on a server.For example31 c 'sleep 100; echo 2'runs the commandsleep 100; echo 2in a screen session then sends you an email with the output of the command once it is complete.SetupInstall 31 by runningpip install 31Then set up your email address by running31 config email youremail@example.comQuick dependency setupOn ubuntu you can runsudo apt install screen mailutilsto quickly set up the dependencies needed.Detailed dependency setupMail programBy default,31searches for a mail program to use from the following list. You
can also force it to use one of the programs by using the command31 config mail_program <mail program name>gnu_mail. To install on ubuntu you can runsudo apt install mailutilsmutt. To install on ubuntu you can runsudo apt install muttScreen ManagerCurrently 31 only supportsscreen. To install screen on ubuntu runsudo apt install screenOptionsSee31 -hfor a full list of options. This section covers only some of the more complicated onesForeachThis option allows you to run multiple commands with text substitution. As a basic usage example, the code31c-f%x1,2,3'touch %x.txt'Creates each of the files1.txt,2.txt, and3.txt. The variable substitution is managed via direct text-substitution,
and thus your variables do not need to begin with %, this works equally well (though is far less readable)31c-f21,2,3'touch 2.txt'You can also modify two variables in tandem like this:31c-f2%x%ext1,2,3txt,png,py'touch %x.%ext'This creates the files1.txt,2.png,3.py. If you instead want to create all combinations, you can run:31c-f%x1,2,3-f%exttxt,png,py'touch %x.%ext'This creates the files1.txt,1.png,1.py,2.txt,2.png,2.py,3.txt,3.png,3.py.The values field is in comma-separated-value form, which means you can use"as a CSV escape, as such:31-c-f%x'",",2'`touch%x.txt`which creates the files,.txtand2.txt.
Package: 310-notebook
310_notebookA JupyterLab extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstall310_notebookUninstallTo remove the extension, execute:pipuninstall310_notebookContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the 310_notebook directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstallpipuninstall310_notebookIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink named310_notebookwithin that folder.Testing the extensionFrontend testsThis extension is usingJestfor JavaScript code testing.To execute them, execute:jlpm
jlpmtestIntegration testsThis extension usesPlaywrightfor the integration tests (aka user level tests).
More precisely, the JupyterLab helperGalatais used to handle testing the extension in JupyterLab.More information are provided within theui-testsREADME.Packaging the extensionSeeRELEASE
Package: 311devs_peewee
.. image:: http://media.charlesleifer.com/blog/photos/p1423749536.32.pngpeewee======This is just `peewee-2.10.2 <https://github.com/coleifer/peewee>` with some changes we need:* Simple LEFT JOIN LATERAL. No need make subquery, just join to model... code-block:: python# make some compound select querysubq = ModelB.select(ModelB.id).where(ModelB.id > ModelA.id).limit(1)# make query lateral joining subqueryModelA.select(ModelA, subq.c.id).join(subq, join_type=JOIN.LATERAL)* Add off argument to for_update method.. code-block:: python# Lock books of author name == JohnBook.select().join(Author).where(Author.name == 'John').for_update(of=Book)
Package: 36-chambers
36-chambers is a Python Library which adds common reversing methods and
functions for Binary Ninja. The library is designed to be used within Binary
Ninja in the Python console.InstallationUse pip to install or upgrade 36-chambers:$ pip install 36-chambers [--upgrade]Quick ExampleFind and print all blocks with a “push” instruction:fromchambersimportChamberc=Chamber(bv=bv)c.instructions('push')DocumentationFor more information you can find documentation onreadthedocs.
Package: 392304jk324nkkl
An example package. Generated with cookiecutter-pylibrary.Free software: BSD 2-Clause LicenseInstallationpip install ex11DocumentationTo use the project:importex1ex1.longest()DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2019-04-04)First release on PyPI.
Package: 3color-Press
About======3color Press is a flask based application intended to streamline making your own comic based website.It is a static website generator that takes markdown formatted text files and turns them into new pages.I am new to programming and I'm kind of brute learning python and flask with this project.The project is under heavy development and features are being added as we work on them,however a very functional core set of features is includedFor more in depth information on how to use check the doc pages You can see a demosite generated with version 0.1 of this tool at http://3color.noties.orgFeatures* automatic handling of book pages, news pages and single pages* easily add a page to the main menu* easily add custom single pages* News page to collect news feed page* Support for showing a thumbnail of most recent comic in desired story line on every page* command line tools for easy managementIn Progress Features* custom themeing support* toggle-able theme elements* improvement on handling in site menus* admin interface* better error checking* much more?!Installation-------------The package is available in pypi::$ pip install 3color-Presssee :doc:`install`Contribute----------If you're interested in contributing or checking out the source code you can take a look at:* Issue Tracker: https:github.com/chipperdoodles/3color/issues* Source Code: https:github.com/chipperdoodles/3colorSupport-------If you're having problems or have some questions,feel free to check out the github page: https://github.com/chipperdoodles/3colorLicense--------3color-Press is (c) Martin Knobel and contributors and is licensed under a BSD licensesee :doc:`license`
Package: 3d-connectX-env
3d-connectX-env3D connectX repository, developed for theOpenAI Gymformat.InstallationThe preferred installation of3d-connectX-envis frompip:pipinstall3d-connectX-envUsagePythonimportgym_3d_connectXimportgymenv=gym.make('3d-connectX-v0')env.reset()env.utils.win_reward=100env.utils.draw_penalty=50env.utils.lose_penalty=100env.utils.could_locate_reward=10env.utils.couldnt_locate_penalty=10env.utils.time_penalty=1env.player=1actions=[0,0,1,1,2,2,4,4,0,0,1,1,2,2,0,3]foractioninactions:obs,reward,done,info=env.step(action)env.render(mode="plot")EnvironmentsThe environments only send reward-able game-play frames to agents;
No cut-scenes, loading screens, etc. are sent to
an agent nor can an agent perform actions during these instances.Environment:3d-connectX-v0Factor at initialization.KeyTypeDescriptionnum_gridintLength of a side.num_win_seqintThe number of sequence necessary for winning.win_rewardfloatThe reward agent gets when win the game.draw_penaltyfloatThe penalty agent gets when it draw the game.lose_penaltyfloatThe penalty agent gets when it lose the game.couldnt_locate_penaltyfloatThe penalty agent gets when it choose the location where the stone cannot be placed.could_locate_rewardfloatThe additional reward for agent being able to put the stone.time_penaltyfloatThe penalty agents gets along with timesteps.first_playerintDefine which is the first player.StepInfo about the rewards and info returned by thestepmethod.KeyTypeDescriptionturnintThe number of the player at this stepwinnerintValue of the player on the winning sideis_couldnt_locateboolIn this step the player chooses where to place the stone.
Package: 3Di-cmd-client
The 3Di command line clientThe 3Di command line client allows forDefining and running 3Di scenarios from the command line.Assembling different scenarios as a "suite" that will be run in batch.Management commands, for instance to list currently running simulations.There are three main entry points for the 3Di command line client.Scenario command$ scenario --help

Usage: scenario [OPTIONS] COMMAND [ARGS]...

Options:
  --endpoint [localhost|staging|production]
                                  The endpoint where commands are run against
  --help                          Show this message and exit.

Commands:
  auth           Provide authentication details
  models         List available threedimodels
  organisations  List available organisations
  results        Download results of a simulation
  run            Run a given scenario
  scenarios      List local scenarios
  settings       Set default settings
  simulations    List simulationsSuite command$ suite --help

Usage: suite [OPTIONS]

  run suite a given suite

Options:
  --suite PATH  path to the suite file  [required]
  --help        Show this message and exit.Active simulations command$ active_simulations --help

Usage: active_simulations [OPTIONS]

  Show currently running simulations

Options:
  --endpoint [localhost|staging|production]
                                  The endpoint where commands are run against
  --help                          Show this message and exit.Dependenciespython >= 3.8InstallationDependencies python >= 3.8pip install --user 3Di-cmd-clientHistory0.0.3 (2020-12-21)Fixed settings context if config file is not yet available.0.0.1b (2020-12-18)First (beta) pypi release.
Package: 3dof-hexapod-ik-generator
This is a simple Python package for hexapod IK calculations.Commands:To be imported as ikengineclass IKEngine # initialises the class object. Takes 4 arguments in mm - coxaLength, femurLength, tibiaLength and bodySideLength. Optionally can take a 5th argument that can either be a list or a tuple. Please pass the servos that need to be reversed into this tuple/list. They will be reversed (angle = 180 - angle) for the whole runtime of your program that utilises this library.shift_lean(posX, posY, posZ, rotX, rotY, rotZ) # returns an array of 18 servo angles that are calculated using IK from the given variables that correspond to the translation and tilt of the body of the hexapod. The order goes from tibia to coxa, from left to right and then from front to backAny questions or suggestions? Please feel free to contact me atmacaquedev@gmail.com