Saravanan666/pypi-org huggingface dataset:
Package: jaraco.nxt
LEGO Mindstorms NXT Bluetooth API in PythonOverviewjaraco.nxtimplements the LEGO Mindstorms NXT Bluetooth API in Python.Thejaraco.nxtlibrary also can take advantage of thejaraco inputpackage.  To include it as part of the install, use the commandpip install jaraco.nxt[input].Getting Startedjaraco.nxtprovides a message class for sending and receiving messages
with the Lego NXT device.  First pair the device with your PC by following
the instructions included with the device.  Then, determine the COM port
to which it is connected.  Thehello world exampleis to retrieve the battery
voltage.Browse the other examplesfor
more inspiration.For more information, read the docstrings of the modules in the packages.Modules of interest arejaraco.nxt.messages: implements the messages defined by
the NXT Bluetooth protocol.jaraco.nxt.controller: demonstrates how to link input from
a joystick to messages controlling the motors.  Uses jaraco.input.
Package: jaraco.packaging
Tools for packaging.sphinxThis package provides a Sphinx extension that will inject into the config
the following values from the project’s package metadata (as presented by
distutils):project (from name)authorcopyright (same as author)versionrelease (same as version)package_url (from url)To enable, include ‘jaraco.packaging’ in the requirements and add
‘jaraco.packaging.sphinx’ to the list of extensions in a Sphinx config
file:extensions=['jaraco.packaging.sphinx']The extension by default builds the project in an isolated environment in
order to extract the metadata. To build the documentation offline,
provide an already built wheel by setting the environment variableJARACO_PACKAGING_SPHINX_WHEELto the path of the existing wheel.make-treeA utility for taking output frompipdeptree--jsonand producing a tree
rooted at a given package.Usage:pipdeptree --json | python -m jaraco.packaging.make-tree mypkg
Package: jaraco.parables
Python library based onXKCD 1263: Reassuring.Based onReassuring-Parable-Generator,
it generates thousands of reassuring parables about things humans
are better than computers at every second.UsageTo use the program, pass the filename of the .cfg you would like to use.Several files are included:reassuring - The standard reassuring parable generator.self-reference - A test file that generates statements about the text generator program.trump - A popular US President.Example$ python -m jaraco.parables reassuring -n 20
Computers won’t be able to understand a piece of music.
A computer never will be able to experience eating a cookie.
A computer won’t experience eating a salad.
A computer will never enjoy a poem.
A computer won’t ever be able to understand a poem.
Computers will never experience a wonderful piece of music.
A computer can’t understand a song.
Computers won’t be able to experience eating a cake.
A computer will never have the ability to enjoy a song.
Computers will never be able to understand a sonnet.
A computer isn’t capable of enjoy a song.
A computer will never be able to experience eating a chicken dinner.
Computers won’t ever be able to experience a superb sonnet.
No computer is capable of taste a piece of pie.
Computers never will be able to enjoy a amazing sonnet.
Computers will never be able to experience eating a cake.
A computer isn’t capable of experience a beautiful poem.
Computers will never have the ability to enjoy a superb sonnet.
Computers won’t ever be able to experience a story.
Computers will never have the ability to experience a play.
Package: jaraco.path
Hidden File Detectionjaraco.pathprovides cross platform hidden file detection:from jaraco import path
if path.is_hidden('/'):
    print("Your root is hidden")

hidden_dirs = filter(is_hidden, os.listdir('.'))Directory BuilderWhen testing (and perhaps in other cases), it’s often necessary to construct
a tree of directories/files. This project provides abuildfunction to
simply create such a directory from a dictionary definition:from jaraco.path import build
build(
    {
        'foo': 'Content of foo',
        'subdir': {
            'foo': 'Content of subdir/foo',
        },
    },
)
Package: jaraco.text
This package provides handy routines for dealing with text, such as
wrapping, substitution, trimming, stripping, prefix and suffix removal,
line continuation, indentation, comment processing, identifier processing,
values parsing, case insensitive comparison, and more. See the docs
(linked in the badge above) for the detailed documentation and examples.LayoutsOne of the features of this package is the layouts module, which
provides a simple example of translating keystrokes from one keyboard
layout to another:echo qwerty | python -m jaraco.text.to-dvorak
',.pyf
echo  "',.pyf" | python -m jaraco.text.to-qwerty
qwertyNewline ReportingNeed to know what newlines appear in a file?$ python -m jaraco.text.show-newlines README.rst
newline is '\n'For EnterpriseAvailable as part of the Tidelift Subscription.This project and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.Learn more.
Package: jaraco.vcs
Usagejaraco.vcs
provides classes for inspecting and working with repositories in the
Mercurial and Git version control systems (VCS).The classes provided are designed to use subprocess invocation to
leverage the command-line interfaces of the VCS toolshgandgit. An
in-process RepoManager for Mercurial exists but has been disabled due to
issues that arise when run in certain environments (namely setuptools
sandboxing).Auto Version NumberingThis project adds support for automatically generating
project version numbers from a source code repository under
development.To use this feature, the project must follow the following assumptions:Repo tags are used to indicate released versions.Tag names are specified as the version only (i.e. 0.1 or v0.1 and
not release-0.1)Released versions currently must conform to the Version inpackaging. Any tags
that don’t match this scheme will be ignored.Thereafter, use the RepoManager.get_current_version to
determine the version of the local code. If the current revision is tagged
with a valid version, that version will be used. Otherwise, the tags in
the repo will be searched, the latest release will be found, and the
function will infer the upcoming release version.For example, if the repo contains the tags 0.1, 0.2, and 0.3 and the
repo is not on any of those tags, get_current_version will return
‘0.3.1dev’ and get_current_version(increment=’0.1’) will return
‘0.4dev’.Example:>>> import jaraco.vcs
>>> jaraco.vcs.repo().get_current_version()
'9.0.1.dev0'
Package: jaraco.video
jaraco.videoimplements a framegrabber inteface for Windows Video Capture
devices.jaraco.videois a port of theVideoCapture modulein pure Python using ctypes
and comtypes.Usagejaraco.videoincludes a console script “save-frame”, which
locates the first video capture device and saves a single frame
to disk as “test.jpg”. The command may also be invoked thus:python -m jaraco.video.captureThis example usage can be seen in the functionjaraco.video.capture:save_frame.
Package: jaraco.windows
A pure-python interface to Windows
APIs using ctypes. This package is not designed to be exhaustive, but
rather to supply interfaces as they are needed by the contributors.Package Contentsjaraco.windowscontains several modules for different purposes. For now,
read the source. Eventually, I hope to put high-level descriptions of the modules
here.InstallationYou should install this module the normal way using pip.If you want to monkeypatch the os module to include symlink compatibility, you
should add the following to yourusercustomizeorsitecustomizemodule:import jaraco.windows.filesystem as fs; fs.patch_os_module()Thereafter, you should be able to useos.symlinkandos.readlinkin Windows
Vista and later using the same interface as on Unix.Note thatjaraco.windows.filesystem.symlinktakes an additional optional
parametertarget_is_directory, which must be specified if the target is not
present and is expected to be a directory once present.ContributeIf jaraco.windows doesn’t supply the interface you require for your
application, consider creating the interface and providing a pull request
to the project.
Package: jaraco.zstd
Extract files from a.tar.zstd:python -m jaraco.zstd --extract filename.tar.zstdUsage:python -m jaraco.zstd --help
usage: zstd.py [-h] -e SOURCE [--out-dir OUT_DIR]

options:
  -h, --help            show this help message and exit
  -e SOURCE, --extract SOURCE
  --out-dir OUT_DIRThis project can be retired ifindygreg/python-zstandard#186is fixed.
Package: jara-utils
Jara means bear inSesotho.Why?Sometimes I start a new project and I need to implement again same methods and after create tests for each method. This package will provide common methods likestr_2_boolor other methods checkREADME.rstfor all methods available.How to contribute to the package?Clone project locally and then:Install all dependencies including the test and the dev oanes:poetry install-Etest-D;Do changes in the project;Create unittests (please make sure  you will keep coverage to 100%);Run all sanity commands (pytest, flake8, mypy, bandit);Check if there is any duplicated or dead fixtures by runningpytestwith--dead-fixturesand--dup-fixtures;Note: Run commands using poetry:poetry run <command>;What you will find in this package?Basically will contain utils methods to avoid write them in all projects. Some examples:decorator to benchmark methods;methods to handle environment variables;some utils methods such as:snake_2_camel,str_2_bool.
Package: jarbas-tasks
============Jarbas tasks============This is a very small module defines a mechanism to inject invoke tasks toJarbas enabled projects. The jarbas-tasks cli is designed to be used as anentry point of a docker container and is used as such in most Jarbas basedimages. By default, it accepts the following sub-commands:Start a bash shell:$ jarbas-tasks bash   # starts a bash shell$ jarbas-tasks run    # run the default "run" task (a bash shell, by default)$ jarbas-tasks tasks  # list all tasks(jarbas-tasks can also be replaced by ``python3 -m jarbas_tasks``)If the CWD has a tasks.py, the jarbas-tasks works basically as a replacement forthe "inv" command which adds a default implementation for the "bash", "run" and"tasks" commands.Run a task defined in tasks.py:$ jarbas-tasks some-taskCreating a task package=======================By default, jarbas-tasks inject only the "run" and "bash" tasks to the list ofavailable tasks. Users can create *task packages* that can inject arbitrarydefault tasks to the jarbas-tasks command.In order to do so, create a Python package that expose the following entrypoint:setup(...,entry_points={'jarbas-tasks': ['mytask1 = mytask:task1',  # Maps command name to task object'mytask2 = mytask:task2',]},}The handler should be a regular invoke task declared anywhere in the module.
Package: jarboto
jarbotoJARVICE container environment config wrapper for boto3Environment configurationThe following values are mandatory:JARVICE_S3_ACCESSKEYJARVICE_S3_SECRETKEYJARVICE_S3_BUCKETNote that thejarboto.S3constructor throwsjarboto.ConfigErrorif one of these values is not setThe following values are optional:JARVICE_S3_ENDPOINTURL(defaults to AWS)JARVICE_S3_PREFIX(defaults tooutput/)JARVICE_S3_REGION(defaults to None)UsageTypical usage pattern when looking to conditionally fetch objects either from S3 or from another source:importjarbototry:buf=jarboto.S3().get(name)exceptjarboto.ConfigError:# alternate method to fetch object follows# ...exceptjarboto.S3Errorase:# actually failed to fetch objectprint(e)Notes:KeepS3object if you intend to perform multiple operations in that context.Runpydoc jarboto.S3for additional help on method use.
Package: jareutil
JAREUTILLaod XML inputfrom jareutil import EvaluationResult, SolutionForXML, laod_input, save_output

solutions = laod_input()Save to XMLfrom jareutil import EvaluationResult, SolutionForXML, laod_input, save_output

result = EvaluationResult(guid,variables,goals,'metadata')
save_output([result])
Package: jarexps
jarexpsSetup a simple Open RPC server to export services from a jar file.Installpip install jarexpsUsageExample config.ymldaemon: true
loglevel: INFO

server:
  listen: 0.0.0.0
  port: 1813

authentication:
  enable: true
  users:
    app01: sNKBMFEol0w8CWUCkgxpxlhzbHeHx264

jarexps:
  classpaths:
    - abs/path/to/bcprov-jdk15on-1.70.jar
  services:
    misc.base64.encode:
      klass: org.bouncycastle.util.encoders.Base64
      method: encode
    misc.base64.decode:
      klass: org.bouncycastle.util.encoders.Base64
      method: decode

orpc:
  handler:
    asio-writer-buffer-size: 4096start server commandjarexpsd -c config.yml startclient testsimport os
import unittest
from orpc.client import OrpcClientPool


class TestJarexps(unittest.TestCase):
    def setUp(self):
        self.cp = OrpcClientPool(
            10,
            kwargs={
                "host": "localhost",
                "port": 1813,
                "username": "app01",
                "password": "sNKBMFEol0w8CWUCkgxpxlhzbHeHx264",
            },
        )

    def test1(self):
        data1 = b"hello world"
        data2 = self.cp.execute("misc.base64.encode", args=[data1])
        assert data2 == b"aGVsbG8gd29ybGQ="

    def test2(self):
        data1 = os.urandom(1024)
        data2 = self.cp.execute("misc.base64.encode", args=[data1])
        data3 = self.cp.execute("misc.base64.decode", args=[data2])
        assert data1 == data3Releasesv0.1.25First release.v0.1.26Doc update.
Package: jarg
jargis an encoding shorthand for your shell.
It is a command-line utility that makes generating data in formats like JSON, YAML, and form encoding easier in the shell.InstallationInstall fromPyPI:$ pip install jargUsageEach argument tojargshould be in the format ofname=value.
Values are interpreted as their closest native encoding value, and the default dialect is JSON.
The most common case is probably string names and values:$ jarg foo=bar baz=quux
{"foo": "bar", "baz": "quux"}Floats and integers will work too:$ jarg foo=10 bar=4.2
{"foo": 10, "bar": 4.2}The value is optional.
If you leave it out, it is interpreted asnull:$ jarg foo
{"foo": null}Thenameportions have the same syntax and semantics asHTML JSONnames:$ jarg foo[]=bar foo[]=baz bar[baz]=quux
{"foo": ["bar", "baz"], "bar": {"baz": "quux"}}You can also write literal values directly, using thename:=valuesyntax.
That lets you write things like booleans, lists, and explicit strings:$ jarg foo:=true bar:=\"123\"
{"foo": true, "bar": "123"}
$ jarg foo:=[1,2,3]
{"foo": [1, 2, 3]}DialectsThe default dialect is JSON, and includes support for YAML and form encoding.To use the YAML dialect, use the-y/--yamlswitch:$ jarg -y name=jarg type="cli tool" traits[]=dope traits[]=rad
---
name: jarg
traits: [dope, rad]
type: cli toolYou can switch to the form encoding dialect with the-f/--formswitch:$ jarg -f foo=bar baz="jarg is dope"
foo=bar&baz=jarg+is+dope
Package: jargon-distance
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.Description: # Jargon DistanceJason Portenoy 2018Implement the jargon distance measure from <a href=”https://doi.org/10.15195/v1.a15” target=”_blank”>Vilhena et al. “Finding Cultural Holes: How Structure and Culture Diverge in Networks of Scholarly Communication.” (2014)</a>### InstallationInstall from PyPI:pip install jargon-distance### UsageInitialize aJargonDistanceinstance with aterm_countsdict and (optionally) agroup_mapdict.term_countsis a mapping of document -> term counter (Counter object).` from jargon_distance import JargonDistance j = JargonDistance(term_counts) `Then, calculate the jargon distances:` j.calculate_jargon_distance()j.write_to_file('jargon_distance.csv')`Thejargon_distance.analysismodule can be used to visualize the jargon distance calculations. For example, below is a dendrogram showing the jargon distances between the text (unigrams) of different works of literature (from the [demo.ipynb](demo.ipynb) notebook).![Dendrogram showing the jargon distance between different works of literature.](literature_dendrogram.png)See [demo.ipynb](demo.ipynb) for a more detailed example.Platform: UNKNOWN
Description-Content-Type: text/markdown
Package: jarguments
jargumentssimplifying args jargonSummaryProviding a straightforward way to create command-line arguments.Works on Python 3.6 and above. Tested on Windows 10.ContentsSummaryContentsInstallationUsageLibraryCommand-lineInstallationgitclonehttps://github.com/silvncr/jarguments.gitcdjarguments
pythonsetup.pyinstallUsageLibraryThere are three steps to using the jarguments library:Import the jarguments library.fromjargumentsimport*Provide your arguments with jarguments' classes.args=JParser(JBool('show_text',help='determines whether "text" is shown'),JStr('text'),)Use your outputs; they are parsed automatically.ifargs.show_text:print(args.text)Command-lineNow you can run your script with arguments:$pythonscript.py--show_text--text"hello world"helloworldArguments without a default value are required. If you don't provide them, the script will raise an error:$pythonscript.py--show_text
error:thefollowingargumentsarerequired:--textIf you want to see help messages, run your script with the-hor--helpflag:$pythonscript.py-h
usage:script.py[-h][--show_text]--textTEXT

options:-h,--helpshowthishelpmessageandexit--show_text[SHOW_TEXT]determineswhether"text"isshown--textTEXT
Package: jarmanifest
Extract manifest information from Java library files (jars).DescriptionUse this library to look at jar META-INF/MANIFEST files and extract Implementation-Title, and Implementation-Version. Based on the specification of jars found [here](http://docs.oracle.com/javase/1.4.2/docs/guide/jar/jar.html#Notes)Installationpip install virtualenvA jarmanfiest.cfg file should you copied to your python’setcdirectoryUsage$ python3>>> from jarmanifest import manifest>>> manifest.getAttributes(‘/tmp/spring/META-INF/MANIFEST.MF’)[{‘implementationtitle’: ‘org.springframework.core’, ‘implementationversion’: ‘3.1.3.RELEASE’}]
Package: jar_manifest
To get a jar file’s manifest as dict, just:>>> import jar_manifest
>>> jar_manifest.manifest('junit-4.12.jar')
{
      "junit-4.12.jar": [
        {
          "Archiver-Version": "Plexus Archiver",
          "Build-Jdk": "1.6.0_45",
          "Built-By": "jenkins",
          "Created-By": "Apache Maven 3.0.4",
          "Implementation-Title": "JUnit",
          "Implementation-Vendor": "JUnit",
          "Implementation-Vendor-Id": "junit",
          "Implementation-Version": "4.12",
          "Manifest-Version": "1.0"
        }
      ]
    }
Package: jarmetainforeader
jarmetainforeaderReturns and prints the contents of the manifest, pom.xml and pom.properties file of a given jar file in the dictionary format.Originaly, This is forked fromhttps://github.com/badari412/jarmanifestreader.
I added function to find metafiles(MANIFES.MF, pom.xml and pom.properties).Compatible with python versions > 3.x versions.Installation:pip install jarmetainforeaderSample usage:If you want to print result>>> from jarmetainforeader import meta_file_reader
>>> meta_file_reader.print_manifest_contents('/Users/secuof/Downloads/commons-lang-2.4.jar')

>>>
>>> meta_file_reader.print_pom_properties_contents('/Users/secuof/Downloads/commons-lang-2.4.jar')

>>>
>>> meta_file_reader.print_pomxml_contents('/Users/secuof/Downloads/commons-lang-2.4.jar')If you want to get data>>> from jarmetainforeader import meta_file_reader
>>> meta_file_reader.get_manifest_contents('/Users/secuof/Downloads/commons-lang-2.4.jar')

>>>
>>> meta_file_reader.get_pom_properties_contents('/Users/secuof/Downloads/commons-lang-2.4.jar')

>>>
>>> meta_file_reader.get_pomxml_contents('/Users/secuof/Downloads/commons-lang-2.4.jar')
Package: jarn.checkinterval
Computes the optimal interpreter check interval for the machine it is run on.
The formula is as follows:<result of pystone benchmark> / 50Installation and useThe checkinterval script must be installed into the Python interpreter used to
run Zope. This is most easily achieved by adding a part to your buildout.cfg:[buildout]
parts = checkinterval

[checkinterval]
recipe = zc.recipe.egg
eggs = jarn.checkintervalAfter re-running buildout, type:$ ./bin/checkinterval
1305The number you see is the recommended check interval for this machine; put it
into your zope.conf file:python-check-interval 1305Now restart Zope and bask in the glow.Why care?The Python Library Reference on the topic ofcheck interval:“This integer value determines how often the interpreter checks for periodic
things such as thread switches and signal handlers. The default is 100,
meaning the check is performed every 100 Python virtual instructions.
Setting it to a larger value may increase performance for programs using
threads.”Now, the Zope application server is such a program, and it benefitsgreatlyfrom setting the right check interval. If the value is too low, Zope
threads are interrupted unnecessarily, causing a noticable performance hit on
today’s multi-cpu hardware.Where’s the 50 coming from?The constant 50 in the formula was determined by benchmarks performed at Zope
Corporation and has become part of the “Zope lore” (See e.g.  this post byMatt Kromer). Going beyond pystone/50 produced no further benefits.The value may well be meaningless for applications other than Zope and
platforms other than Intel.BackgroundMore on check intervals and the GIL fromDavid Beazly.For those back from the Beazly talk: Zope uses long running threads andasyncore, making it (more) independent from OS scheduling issues. Still,
the interruption argument holds.Changelog1.0 - 2009-06-13Initial release
Package: jarniadice
A library for parsing and evaluating Jarnia Dice Notation.In the future, we aim to have all the features of standard Dice Notation,
but also more.The current stage of development is pre-alpha, and I’m running
this library only on a private telegram bot and implementing
the features as I need.Documentation (Draft)Run three d6 and return thesum:$ python -m jarniadice '3d6'Run two d10 and return the value of thehigher:$ python -m jarniadice '2d10kh'Run two d10 and return the value of thelower:$ python -m jarniadice '2d10kl'Run two d10 and returnallthe values as anumpy.ndarray:$ python -m jarniadice '2d10kl'