Saravanan666/pypi-org huggingface dataset:
Package: joker-mongodb
joker-mongodbAccess mongodb with handy utilities and fun.Connnect to multiple mongo servers with MongoInterfaceExample:GlobalInterfaceis defined inexample/environ.pyas:fromfunctoolsimportcached_propertyimportvolkanicfromjoker.mongodb.interfacesimportMongoInterfaceclassGlobalInterface(volkanic.GlobalInterface):package_name='example'default_config={"mongoi":{"local":{},"remote":{"host":"192.168.22.122","port":27017}}}@cached_propertydefmongoi(self)->MongoInterface:returnMongoInterface.from_config(self.conf['mongoi'])If a configuration file is found at one of the follow locations:Under your project directory in a development enviornment~/.example/config.json5/etc/example/config.json5/example/config.json5it will overrideGlobalInterface.default_config.Usage in codeexample/application.py:frombsonimportObjectId# noinspection PyUnresolvedReferences,PyPackageRequirementsfromexample.environimportGlobalInterfacegi=GlobalInterface()defget_product(product_oid):coll=gi.mongoi.get_coll('remote','example','products')returncoll.find_one({'_id':ObjectId(product_oid)})if__name__=='__main__':print(get_product('60f231605e0a4ea3c6c31c13'))Recent changesversion 0.1.4addMongoDocumentSchematorandMongoFieldSchematorversion 0.1.3addTransactionHelper
Package: joker.py
Joker.pyAboutA simple python package to get jokes and puns.How to use?You can use this by package fromJoker.pypipinstalljoker.pyWhy use this?To fetch jokes and puns on your projects.How to use?fromjokerimportJokerjoker=Joker()joke=joker.joke()print(joke)puns=joker.puns(5)forpuninpuns:print(pun)Want To Contribute?You can send a pull request or open an issue to contribute.
Check outCode Of Conductbefore contributing.
Package: joker-studio
joker-studioCLI tools for media file editing, wrapping FFmpeg and othersInstall withpip(addsudoif necessary):python3 -m pip install joker-studioCropExample:dio crop -c 0 0 .1 .2 -t 120 60 myvideo.mp4This command willremove the leading 2 minutes and trailing 1 minutecrop 10% at bottom and 20% on the leftsave result asmyvideo.crop.mp4(originalmyvideo.mp4untouched)ConvertConvert multiple.tsvideos to.mp4:dio conv video1.ts video2.tsExtract audio from video as.mp3:dio conv -f mp3 -f myvideo.mp4SplitSplit a video into 4 segments of equal duration:dio split -n 4 myvideo.mp4Split into segments, each (but the last one) of duration 5 minutes (300 seconds):dio split -s 300 myvideo.mp4FadeAdd 10 sec audio fade-in, 6 sec video fade-in, 4 sec video fade-outdio fade -a 10 0 -v 6 4 myvideo.mp4Burn subtitleThis command generates a video with hard subtitle namedmyvideo.wSub.mp4dio sub -s myvideo.english.srt myvideo.mp4Rename filesRemove all "unsafe" characters on Unix-like systems, i.e. characters you should quote in shell scripts,
and invalid characters on Microsoft Windows:dio ren -f san *.jpgRenamewaterlife.jpgtoimg-800x600.waterlife.jpg:dio ren -f img waterlife.jpgRenamelightning.jpgtoih-F8F07B7F3F0E0E0F.lightning.jpg, whereF8F07B7F3F0E0E0Fis animagehashdio ren -f ih lightning.jpgMore info:dio ren -h
Package: joker-superuser
joker-superuserCommandline utilitiesGenerate UUID:$ sus uuid
8EDFF28CB26A4C13BF8D4AD8BDC5434A

$ sus uuid -s
FC8A0CC5-63BE-459A-8E86-AD8A1A87A767

$ sus uuid -sl
836a9b1f-a5ac-418d-9cce-1b06f3ac24e6Compute Base32 encoded SHA1 checksums:sus sha1b32 example.txt
find . -type f -exec sus sha1b32 {} \;Compute Base64 encoded SHA384 checksums:sus sha384b64 example.txt
find . -type f -exec sus sha384b64 {} \;MiscellaneousGet resources with SVN:svn export https://github.com/frozflame/joker-superuser/trunk/resources sus-resourcesGet resources with curl and tar:mkdir sus-resources
curl -L "https://github.com/frozflame/joker-superuser/archive/master.tar.gz" | tar xz -C sus-resources --strip-components 2 joker-superuser-master/resources/Recent changesversion 0.2.5add sub-commandsl(locators) andchksumdirrequire Python version 3.6+
Package: joker-xopen
joker-xopenxopencommand (client)Without any config, you can usexopenas a cross-platform versionxdg-open(Linux),open(macOS) orstart(Windows).$ xopen https://www.pypi.org 
$ xopen ~/sample-video.mp4Show help:$ xopen -hServerShow help$ python3 -m joker.xopen.server -hPut a text file at~/.joker/xopen/xopen.txt, with content likec   ~/Code
w   /var/www/html
ns  /etc/nginx/servers
ff  https://github.com/frozflameRun server:$ python3 -m joker.xopen.serverThen try$ xopen c
$ xopen ffTo save some typing, you can givexopenan alias. Add in~/.bashrcor~/.zshrc:alias xo=xopen
Package: jokes_daily
Jokes Daily is a simple CLI appContains no additional dependencies(completely built off of Standard lib)How to install?$pipinstalljokes_daily
$jokes_daily# default - two part jokes# Q) What do you call a pile of kittens?# A) A meowntain.$jokes_daily-s1# one line jokes# I have a joke about trickle down economics, but 99% of you will never get it.Configure jokes_daily to generate a joke everytime you open your terminal# For BASH$echo"jokes_daily">>~/.bashrc# For ZSH$echo"jokes_daily">>~/.zshrcFeel free to fork and tweak it to your liking.PRs are welcome!Author -Nikhil Akki
Package: jokettt
JokeTTT: a Tic Tac Toe game developed by jokeJokeTTT is a library providing tic tac toe structures useful to develop games based on several kind of players.
It was developed just for fun and to learn Python and some concepts of machine learning.Project setupThe project has been tested only with python3 on Ubuntu Linux. If you have python3 installed in your machine, just install the package with the usualpipcommand.To avoid the usual problems with messy Python configurations (python 2 vs. 3, packages to install, etc.), conda is used for development.For those that wants to do the same and does not know conda, this is a a quick reference:TDHopper article on python environment with condaGet your computer ready for machine learning using *condaIf you have conda installed, enter the project directory (the one with the environment.yml file) and enter the following command:condaenvcreateThis shall be done only the one time. After this thejoketttconda environment is created. It can be activated with the command:condaactivatejoketttTo update the conda environment every time that theenvironment.ymlis changed, enter the command:condaenvupdateDemo programsFor example of simple applications that uses the jokettt classes, see thejokettt_demorepository.CreditsA.L. AradhyaMinimax introduction article(and all the following) in geeksforgeeks.org for implementation of the minimax playerT. Simonini "An introduction to reinforcement learning" for introduction theory on value function and for directing me to the Sutton and Barto book.
Package: jokk
RESTful mock api server.Jokkis heavily inspiered byEasyMock.RepositoryDocumentationInstallation$ virtualenv --distribute jokk_sample
$ source jokk_sample/bin/activate
$ cd jokk_sample
$ pip install jokkJokkdepends onWerkzeugusing for WSGI Utility Library.UsageCreateconfig.jsonfor configure settings such as routes, variablesCreatedatadirectory for serve response filesPut response file intodatadirectoryStart Jokk server$ jokk -c config.jsonAccess to jokk server client such as Web browser.Jokk would return response fileOptionsSee documantaion.ContributingFork itCreate your feature branch (git checkout -b my-new-feature)Commit your changes (git commit -am ‘Add some feature’)Push to the branch (git push origin my-new-feature)Create new Pull Request
Package: joklib
This Library allows you with only a few lines of code to read out the klima data from J-O. Techniks Klimaboxen.
If you dont have one of these or a simmillar system you wouldnt probably use this library, because its main
function is to provide a simple accsess to them and also a few other things that good python programmers doesn`t
need, cause of their experience.Copyright 2020 Jan-Ole G. (J-O. Technik)
Package: jokyjokes
# jokyjokesUseless package built for learning packaging python projects that provides you jokes.## UsageThere are 3 modules so far, which are the following:```pythonfrom jokyjokes import chucknorris  # chuck norris jokesfrom jokyjokes import yomama       # yo mama jokesfrom jokyjokes import topkek       # topkek jokes```And each module contain 10 jokes with 3 methods, which are the following:```pythonchucknorris.random()     # returns a random jokechucknorris.joke(0)      # returns the first jokechucknorris.all_jokes()  # returns all jokes as one str```### FAQQ: Why code something like this at all?A: I wanted to learn how to package my python projects and upload them to PyPi. The content of the package is insignificant
Package: joli_users
=====Joli Users=====Joli Users is a django rest framework module for creating and managing users for mobile clientsDetailed documentation is in the "docs" directory.Quick start-----------1. Add "joli_users" and "rest_framework.authtoken" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'joli_users','rest_framework.authtoken']2. Add these variables in settings::JOLI_USERS_USER_GROUP_NAME = 'example group' #eg users, mobileUsersJOLI_USER_PHOTOS_PATH = '/example_proj/example_path/'JOLI_USERS_EMAIL_SUBJECT = 'example_subject'JOLI_USERS_EMAIL_BODY_TEXT = 'example test'JOLI_USERS_EMAIL_FROM = 'example@example.com'JOLI_USERS_ACCOUNT_ACTIVATION_DAYS = 7EMAIL_HOST = 'smtp.example.com'EMAIL_PORT = 587EMAIL_USE_TLS = TrueEMAIL_HOST_USER = 'example@example.com'EMAIL_HOST_PASSWORD = 'example_password'2. Include the joli_users URLconf in your project urls.py like this::url(r'^joli_users/', include('joli_users.urls')),3. Run `python manage.py migrate` to create the polls models.4. Start the development server and visit http://127.0.0.1:8000/admin/to create a group (you'll need the Admin app enabled).5. Visit http://127.0.0.1:8000/joli_users/ to participate in the poll.
Package: jolli
jollijolli isjust anopenPMDlow-levelinterface for reading and plotting PIConGPU output in python. It is a simple wrapper for the openPMD-api to read PIConGPU outputIt is currently under development and not recommended for production! It currently obnoxious works for 2D data, is slow, and is not well written. But it might be already useful: You will find it very familiar if you are already used to thehappiinterface forSMILEI.The following methods are already implemented, while not all arguments are funtioning, yet:Quickstart:import jolli
S=jolli.Open("/bigdata/hplsim/scratch/kluget/PFT_2/")
units = ["eV","fs","nc","um","a0"]
jolli.Multiplot(
                S.Scalar(scalar="Uelm",units=["eV","fs"]),
                S.Scalar(scalar="Ukin_e",units=units),
                S.Scalar(scalar="Ukin_H",units=units),
                S.Scalar(scalar="Ukin_C",units=units),
                S.Scalar(scalar="Ukin_O",units=units),
               )
dY = S.Scalar(scalar="Ukin_e",units=["me","s"]).getData()
dX = S.Scalar(scalar="Ukin_e",units=["J","steps"]).getAxis()

S.Scalar(scalar="Uelm",units=units).plot()
d1 = S.Scalar(scalar="Uelm",units=units).getData()

S.Energy(units=units).plot()
d2 = S.Energy(units=units).getData()

Ex = S.Field("Ex",timesteps_SI = [80*jolli.fs], units=units)
S.Field("Ex",timesteps_SI = [80*jolli.fs], units=units,average={"x":"all"}).plot()

S.ParticleBinning("H","density",timesteps_SI = [80*jolli.fs], units=units).plot()
S.ParticleBinning("H","density",timesteps_SI = [80*jolli.fs], units=units,average={"x":"all"}).plot()
S.ParticleBinning("H","density",timesteps_SI = [80*jolli.fs], units=units,average={"x":[1*jolli.um,2*jolli.um]}).plot()
d3 = S.ParticleBinning("H","density",timesteps_SI = [80*jolli.fs], units=units).getData()
d3X = S.Scalar(scalar="Ukin_e",units=["J","steps"]).getAxis("x")

S.ParticleFieldSummary(quantity="density",timesteps_SI = [80*jolli.fs], data_log=True,units=units,average={"x":[1*jolli.um,2*jolli.um]}).plot(yrange=[0.01,200])
Package: jolly-brancher
A sweet branch creation suiteDescriptionThe overarching goal here is to facilitate developer time and remove
duplicative work.As a developer, I am more productive (and more descriptive) when I
only have to write the description for what I’m working one one time
(or barring that, as few times as possible).In order to streamline and facilitate the developer’s workflow this
tool aims to connect an arbitrary ticketing system (currently only
JIRA is supported) to a git forge (currently only GitHub is
supported).UsageJolly brancher will, given a repository location create branches from JIRA tickets that automatically include ticket information in the branch, and branch name.Given the repository base directory, you are provided with a list of repositories that you can act on (with tab completion):After choosing a repository, you can either create a branch based on the contents of a ticketAlternatively, if the branch name is well formed, you can create a PR against the parent of the branch, the tool will ask some questions and construct the body of the PR (it scans the CODEOWNERS file and suggests those users as tags), and create it:If you decline to do so, then you will be redirected to the branch creation flow:It will further create a pull review from an existing branch that is well formed:It automatically populates the PR description with information from the ticketConfigurationJIRA and git credentials are required in~/.config/jolly_brancher.iniin the following format:[jira]
auth_email = <author@domain.com>
base_url = https://<subdomain>.atlassian.net
token = <basic_auth_token>

[git]
pat = <personal_access_token>
repo_root = <~/path/to/local/repositories>
forge_root = https://github.com/<organization_name>/Future FeaturesExtract the contents of the comments in the branch and construct a description of the changes in the branchPerform in place analysis of the branch and add information to the PR
- Were any tests added?
- Run unit tests / linter (fetch from github actions)
- Include other interesting statisticsAutomatically tag the owner of the files that were changedPull the acceptance criteria from the ticket and format it into a list of checkboxes so the developer can indicate which are met by the current revision
Package: jolly-github-toolbelt
GitHub ToolsA collection of tools around Git and GitHub to make developers’ lives easier.gt-assign-prgt-pr-doc-linkgt-assign-prA simple helper to assign a given PR to as set of users from the CLI.UsageThis tool requires the use of a token (seeUsing Tokens).
By simply providing aowner,repository,pr_numberand as many users as desired,
you can assign the given PR to those users.
By default, currently assigned users are kept,
but they can be removed using the--clear-currentflag.gt-pr-doc-linkA simple helper to post a link to docs back to a PR when run in a Jenkins job.UsageThis tool requires the use of a token (seeUsing Tokens).
In addition,
this tool requires aBUILD_URLenvironment variable to be present
(present automatically in a Jenkins job),
and to have the docs already built
and available via a URL subpath from the job URL,
as would be generated by theJenkins HTML Publisherplugin.Using TokensIn order to provide for maximum flexibility,
these tools are designed to work with GitHub Personal Access Tokens,
which are needed for people using two-factor authentication
or have access protected by SAML single sign on (SSO).
GitHub provides instruction toobtain a token.
The token can be provided to all commands
either via the--tokenTOKENflag,
or by settingGH_TOKENin your environment.Custom GitHub URLBy default, this project works withhttps://github.com.
In order to use an alternate URL, such as an enterprise install,
you can provide the URL via an environment variable:GT_GH_URL.pre-commit hooksThis repository also provides three hooks, documented below,
that can be installed by hand or viapre-commit:gt-commit-msgEnsure that a commit message conforms to some best practices:Subject lines should not be longer than 50 charactersWrap the body at 72 charactersSeparate the subject from body with a blank line.These are taken fromA Note About Git Commit Messages.gt-self-checkCan perform validations before making a commit.
If an executable file namedself-check.shexists
in the root of the repository and a Python, Ruby, or Gherkin file was changed,
the checker is executed
and the return status serves as a gate for the commit to occur.
The check can be bypassed viagit commit-n.gt-prepare-commit-msgPrepare a commit message by including an appropriate prefix,
when possible, based on the branch name.
If the branch name contains a JIRA ID, that is included in the prefix.
If the branch name also contains either “FF” or “Spike”,
that is appended to the prefix.
If a branch name, without including a JIRA ID,
contains “FF”, “Spike”, “Enhancement” or “Fix”,
those phrases are set as the prefix.
All searches are case-insensitive.
Package: jollyjumper
Scansion tool for Spanish textsFree software: Apache Software License 2.0Installationpip install jollyjumperDocumentationhttps://jollyjumper.readthedocs.io/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.1 (2019-02-21)First release on PyPI.
Package: jolt
Jolt is a task execution tool designed for software development tasks.
It can build your C/C++ applications and React frontends, run tests, deploy your web services,
and much more.Tasks are defined in Python scripts. They may be executed locally by developers or by automation software
such as Jenkins in a continuous integration pipeline. In both cases, tasks may be distributed and executed
in parallel in a server cluster. The output of each task is cached to reduce overall execution times on
repeat attempts. In one real world deployment, Jolt shortend the CI build duration from 10 hours to 10 minutes
on average.Example C++ application task:classCppApp(CXXExecutable):""" Builds a C++ application """arch=Parameter(values=["arm","x64"])requires=["git:url=https://github.com/org/cppapp.git","gcc:arch={arch},version=9.1.1",]sources=["cppapp/include/*.hpp","cppapp/src/*.cpp"]$joltbuildcppapp:arch=x64Example Node.js tasks:classNodeJS(Download):""" Downloads and publishes Node.js. Adds binaries to PATH. """version=Parameter("14.16.1")url="https://nodejs.org/dist/v{version}/node-v{version}-win-x64.zip"defpublish(self,artifact,tools):super(publish).publish(artifact,tools)artifact.environ.PATH.append("node-v{version}-win-x64")classWebApp(Task):""" Builds a really cool WebApp """requires=["git:url=https://github.com/org/webapp.git","nodejs"]defrun(self,deps,tools):withtools.cwd("webapp"):tools.run("npm ci")tools.run("npm build")$joltbuildwebappA common command line interface for all tasks enables developers from different
disciplines to quickly run each others tasks without in-depth knowledge of the underlying technology -
a C++ developer doesn’t have to learn NPM and a React developer doesn’t have to know anything about
CMake, Make, MSBuild, etc. Required tools and dependencies are also provisioned automatically.For full documentation, please visithttp://jolt.readthedocs.io/InstallingJolt is available in the Python Package Index:$pipinstalljolt$joltAnd as a Docker image:$dockerrunrobrt/joltA thin Python wrapper is available for the Docker images. By using it, multiple versions
of Jolt can coexist on the host since the version used is selected during runtime rather
than install time. To use a specific version in a project, add a version attribute in the
Jolt manifest. By always using a specific version cache hits become more likely.$pipinstalljolt_docker$jolt
Package: jolt-docker
Jolt is a task execution tool designed for software development tasks.
It can build your C/C++ applications and React frontends, run tests, deploy your web services,
and much more.Tasks are defined in Python scripts. They may be executed locally by developers or by automation software
such as Jenkins in a continuous integration pipeline. In both cases, tasks may be distributed and executed
in parallel in a server cluster. The output of each task is cached to reduce overall execution times on
repeat attempts. In one real world deployment, Jolt shortend the CI build duration from 10 hours to 10 minutes
on average.Example C++ application task:classCppApp(CXXExecutable):""" Builds a C++ application """arch=Parameter(values=["arm","x64"])requires=["git:url=https://github.com/org/cppapp.git","gcc:arch={arch},version=9.1.1",]sources=["cppapp/include/*.hpp","cppapp/src/*.cpp"]$joltbuildcppapp:arch=x64Example Node.js tasks:classNodeJS(Download):""" Downloads and publishes Node.js. Adds binaries to PATH. """version=Parameter("14.16.1")url="https://nodejs.org/dist/v{version}/node-v{version}-win-x64.zip"defpublish(self,artifact,tools):super(publish).publish(artifact,tools)artifact.environ.PATH.append("node-v{version}-win-x64")classWebApp(Task):""" Builds a really cool WebApp """requires=["git:url=https://github.com/org/webapp.git","nodejs"]defrun(self,deps,tools):withtools.cwd("webapp"):tools.run("npm ci")tools.run("npm build")$joltbuildwebappA common command line interface for all tasks enables developers from different
disciplines to quickly run each others tasks without in-depth knowledge of the underlying technology -
a C++ developer doesn’t have to learn NPM and a React developer doesn’t have to know anything about
CMake, Make, MSBuild, etc. Required tools and dependencies are also provisioned automatically.For full documentation, please visithttp://jolt.readthedocs.io/InstallingJolt is available in the Python Package Index:$pipinstalljolt$joltAnd as a Docker image:$dockerrunrobrt/joltA thin Python wrapper is available for the Docker images. By using it, multiple versions
of Jolt can coexist on the host since the version used is selected during runtime rather
than install time. To use a specific version in a project, add a version attribute in the
Jolt manifest. By always using a specific version cache hits become more likely.$pipinstalljolt_docker$jolt
Package: joltedmod
JoltedModJoltedMod is a Python package that utilizes OpenAI's chat models to automatically generate Jupyter Notebook or Markdown-based computer science educational materials. This package can be integrated into a frontend application, such as a CLI or API, to serve educational content.FeaturesGenerate Jupyter Notebook or Markdown content based on a given topicHighly configurable using tutorial template JSON structureCustomizable content creator identity and target audienceSupport for GPT-3.5-turbo and other OpenAI modelsInstallationTo install JoltedMod, you can usepip:pip install jolted_modUsageHere's an example of how to generate a Jupyter Notebook module for a given topic:importasynciofromjolted_mod.mainimportcreate_notebook_moduletopic="Intro to for loops in Python"identity="professor of computer science"target_audience="first year computer science students"is_code=Truemodel="gpt-3.5-turbo"tutorial_content=asyncio.run(create_notebook_module(topic,identity,target_audience,is_code,model))print(tutorial_content)ConfigurationYou can customize the generated content using a JSON template structure that outlines blocks. An example template file can be found intutorial_template.json.Development SetupJoltedMod uses Poetry for project management. To set up a development environment, follow these steps:Install Poetry if you haven't already:curl -sSL https://install.python-poetry.org | python3 -Clone the repository:git clone https://github.com/yourusername/jolted_mod.git
cd jolted_modInstall dependencies using Poetry:poetry installActivate the virtual environment:poetry shellNow you're ready to start contributing to JoltedMod!ContributingIf you'd like to contribute to JoltedMod, feel free to fork the repository and submit a pull request.LicenseJoltedMod is licensed under theMIT License.