Saravanan666/pypi-org huggingface dataset:
Package: klass-registry
ClassRegistryAt the intersection of the Registry and Factory patterns lies theClassRegistry:Define global factories that generate new class instances based on
configurable keys.Seamlessly create powerful service registries.Integrate with setuptools’sentry_pointssystem to make your registries
infinitely extensible by 3rd-party libraries!And more!Getting StartedCreate a registry using theklass_registry.ClassRegistryclass, then
decorate any classes that you wish to register with itsregistermethod:fromklass_registryimportClassRegistrypokedex=ClassRegistry()@pokedex.register('fire')classCharizard(Pokemon):...@pokedex.register('grass')classBulbasaur(Pokemon):...@pokedex.register('water')classSquirtle(Pokemon):...To create a class instance from a registry, use the subscript operator:# Charizard, I choose you!fighter1=pokedex['fire']# CHARIZARD fainted!# How come my rival always picks the type that my pokémon is weak against??fighter2=pokedex['grass']Advanced UsageThere’s a whole lot more you can do with ClassRegistry, including:Provide args and kwargs to new class instances.Automatically register non-abstract classes.Integrate with setuptools’sentry_pointssystem so that 3rd-party
libraries can add their own classes to your registries.Wrap your registry in an instance cache to create a service registry.And more!For more advanced usage, check out the documentation onReadTheDocs!RequirementsClassRegistry is compatible with Python versions 3.7, 3.6, 3.5 and 2.7.InstallationInstall the latest stable version via pip:pip install klass-registryRunning Unit TestsTo run unit tests after installing from source:python setup.py testThis project is also compatible withtox, which will run the unit tests in
different virtual environments (one for each supported version of Python).To run the unit tests, it is recommended that you use thedetoxlibrary.
detox speeds up the tests by running them in parallel.Install the package with thetest-runnerextra to set up the necessary
dependencies, and then you can run the tests with thetoxcommand:pip install -e .[test-runner]
tox -vTipTo run tests for multiple Python versions in parallel:# Python 3.7 only
tox -p all

# Python 3.6 or earlier
pip install detox
detoxDocumentationDocumentation is available onReadTheDocs.If you are installing from source (see above), you can also build the
documentation locally:Install extra dependencies (you only have to do this once):pip install '.[docs-builder]'Switch to thedocsdirectory:cd docsBuild the documentation:make html
Package: klaus
klaus: a simple, easy-to-set-up Git web viewer that Just Works™.(If it doesn’t Just Work for you, please file a bug.)Super easy to set up – no configuration requiredSyntax highlightingMarkdown + RestructuredText rendering supportPull + push support (Git Smart HTTP)Code navigation using Exuberant ctagsDemo:http://klausdemo.lophus.orgMailing list:http://groups.google.com/group/klaus-usersOn PyPI:http://pypi.python.org/pypi/klaus/Wiki:https://github.com/jonashaag/klaus/wikiLicense:ISC (BSD)Running with DockerThe easiest way to get started. We maintain a Docker image that has syntax highlighting, Markdown rendering, code navigation, etc. pre-configured:docker run -v /path/to/your/repos:/repos \
           -p 7777:80 \
           -it jonashaag/klaus:latest \
           klaus --host 0.0.0.0 --port 80 /repos/repo1 /repos/repo2 ...(Replace/path/to/your/reposwith the folder that contains your Git repositories on the Docker host. You can also pass in multiple-varguments if your repos are in multiple folders on the host.)Go tohttp://localhost:7777on the Docker host et voilà!The command line above simply runs theklausscript – for usage details, see the “Using theklausscript” section below.Local setuppip install klaus(Optional dependencies: seeMarkup renderingin the wiki.)UsageSee also:Klaus wikiUsing theklausscriptNOTE:This is intended for testing/low-traffic local installationsonly!
Theklausscript useswsgirefinternally which doesn’t scaleat all(in fact it’s single-threaded and non-asynchronous).To run klaus using the default options:# With Docker:dockerrun...jonashaag/klaus:latestklaus[repo1[repo2...]]# Local setup:klaus[repo1[repo2...]]For more options, see:# With Docker:dockerrun...jonashaag/klaus:latestklaus--help# Local setup:klaus--helpUsing a real serverTheklausmodule contains amake_appfunction which returns a WSGI app.An example WSGI helper script is provided with klaus (seeklaus/contrib/wsgi.py),
configuration being read from environment variables. Use it like this (uWSGI example):uwsgi -w klaus.contrib.wsgi \
      --env KLAUS_SITE_NAME="Klaus Demo" \
      --env KLAUS_REPOS="/path/to/repo1 /path/to/repo2 ..." \
      ...Gunicorn example:gunicorn --env KLAUS_SITE_NAME="Klaus Demo" \
         --env KLAUS_REPOS="/path/to/repo1 /path/to/repo2 ..." \
         klaus.contrib.wsgiThe Docker image also has uwsgi preinstalled:docker run ... jonashaag/klaus:latest uwsgi ...See alsodeployment section in the wiki.ContributingPlease do it!I’m equally happy with bug reports/feature ideas and code contributions.
If you have any questions/issues, I’m happy to help!For starters,here are a few ideas what to work on.:-)
Package: klausen
Copyright (c) 2019, Chris Mutel
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.Description: # Klausen[![Build Status](https://travis-ci.org/cmutel/klausen.svg?branch=master)](https://travis-ci.org/cmutel/klausen) [![Build status](https://ci.appveyor.com/api/projects/status/2j5behso9hlnmj4x?svg=true)](https://ci.appveyor.com/project/cmutel/klausen) [![Coverage Status](https://coveralls.io/repos/github/cmutel/klausen/badge.svg?branch=master)](https://coveralls.io/github/cmutel/klausen?branch=master)Parameterized model framework in Python.## InstallationRequires [stats_arrays](https://stats-arrays.readthedocs.io/en/latest/).Platform: UNKNOWN
Classifier: Intended Audience :: End Users/Desktop
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Topic :: Scientific/Engineering :: Information Analysis
Classifier: Topic :: Scientific/Engineering :: Mathematics
Package: klaviyo-for-django
klaviyo-for-djangoAdd your Klaviyo api key to your Django project's settings.py file.settings.pyKLAVIYO_PRIVATE_API_KEY='YOUR_PRIVATE_API_KEY_HERE'Usagefromklaviyo_for_djangoimportsend_eventsend_event('event_name',profile_find={'email':'profile_email@email.com'},event_properties={'property_name':'property_value'},profile_properties={'other_property_name':'other_property_value'})
Package: klaxon
klaxonSend Mac OS (ornotifiers) notifications from the terminal or Python programs.This is especially useful for when you want a push notification
for some long-running background task.Similar to theterminal-notifier ruby gem,
but posix-compliant and able to send notifications via
thenotifierslibrary.InstallationFor command-line use, the recommended method of installation is throughpipx.pipxinstallklaxonNaturally, klaxon can also be pip-installed.pipinstallklaxonUsageterminal# blank notificationklaxon# with custom messageklaxon--message"this is the message body"# pipe message from other programecho"this is the message body"|klaxon--pythonfromklaxonimportklaxon,klaxonify# send a notificationklaxon(title='hello, klaxon',subtitle='hola',message='it me')# we can decorate our functions to have# them send notifications at termination@klaxonifydefhello(name='world'):returnf'hello,{name}'@klaxonify(title='oh hai',output_as_message=True)deffoo():return"This will be the message body."Non-MacOS Notificationsi.e. mobile | email | slackYou'll need to install klaxon with thenotifiersextra.pipxinstallklaxon[notifiers]You will need a~/.config/klaxon/config.tomlorpyproject.tomlfile with thetool.klaxonnamespace configured at the top level. Values from the latter will
override values in the former.enable-notifierswill need to be set totrueand you will need a[[notifiers]]key.The latter will determine the parameters passed to thenotifiers.notifymethod.For example:~/.config/klaxon/config.tomlenable-notifiers=true[[notifiers]]name='slack'# see https://api.slack.com/incoming-webhooks#getting-startedwebhook_url={{yourwebhookurl}}[[notifiers]]name='pushover'user={{yourusertoken}}token={{yourapplicationtoken}}Voila! Now messages sent from klaxon will be pushed to slack and pushover.Developmentgitclonegit@github.com:knowsuchagency/klaxon.gitcdklaxon# create a virtualenv and activate itpython3-mvenv.venvsource.venv/bin/activate# install poetry and use it to install project dependenciespipinstall-Upip
pipinstallpoetry
poetryinstall# this will install `invoke` which will let you use the tasks defined in `tasks.py`# install pre-commit hooksinvinstall-hooks# from now on, as you make changes to the project, the pre-commit hooks and# github workflows will help make sure code is formatted properly and tests# are invoked as you commit, push, and submit pull requests
Package: klayout-pyxs
klayout_pyxs 0.1.13This is a python port of the XSection project
(https://github.com/klayoutmatthias/xsection).The goal of this project is to provide an add-on to KLayout (www.klayout.de) to
create and visualize a realistic cross-section view for VLSI designs
supporting a wide range of technology options.User DocumentationFor the project description seeklayout_pyxs Project Home Page.Project FilesThe basic structure is:docsThe documentationklayout_pyxsThe python package sourcespymacrosThe python .lym macros files for KLayoutsamplesSome sample filestestsTest sources and golden dataxs2pyxsxs to pyxs conversion scriptsThedocsfolder contains the .rst files and images for the documentation
pages. See rendered versionhere.Theklayout_pyxsfolder contains the python package which includes
the cross-section generation engine.Thepymacrosfolder contains with the actual KLayout macros code,pyxs.lym.Thesamplesfolder holds a few files for playing around.Thetestsfolder contains some regression tests for the package.
To run the tests, make sure "klayout" or "klayout_app" (in Windows)
is in your path and use$cdtests
$./run_tests.shor (from e.g. git bash console on Windows)$cdtests
$bashrun_tests_windows.shThexs2pyxsfolder contains a shell script which helps converting
Ruby-based .xs scripts to .pyxs scripts. It performs necessary but not
sufficient string replacements. Depending on the .xs script complexity,
more changes are likely to be needed.Installation for usersYou can install the modulepip install klayout_pyxsAnd the klayout macro from klayout package manager.Installation for developersTo run .pyxs scripts from the KLayout menu, klayout_pyxs package and
python macros file have to be installed to the KLayout folders.
According toKLayout documentation,
they should go to the "pymacros" and "python" folders in KLayout's user
specific application folder. In Windows, it is $USERPROFILE/KLayout.If you are using Python 2.7 in your KLayout distribution, you needsixpackage installed.WindowsIn Windows, do the following (the commands should be run from e.g.
git bash console). Tested on KLayout 0.25.3 and 0.25.7.Check if $USERPROFILE/KLayout exists and is used by the KLayout to
store macros. Run$ls$USERPROFILE/KLayoutIf no error reported, continue with 1. If there is an error, you need to
find a location of KLayout's user specific application folder
with pymacros, python folders and use it in further commands.Clone klayout_pyxs repository into any source folder:$gitclonehttps://github.com/dimapu/klayout_pyxs.gitklayout_pyxs_repoCopy klayout_pyxs_repo/pymacros/pyxs.lym to $USERPROFILE/KLayout/pymacros/pyxs.lym$cpklayout_pyxs_repo/pymacros/pyxs.lym$USERPROFILE/KLayout/pymacros/pyxs.lymCopy klayout_pyxs_repo/klayout_pyxs/.to $USERPROFILE/KLayout/python/klayout_pyxs$mkdir$USERPROFILE/KLayout/python/klayout_pyxs
$cpklayout_pyxs_repo/klayout_pyxs/*.py$USERPROFILE/KLayout/python/klayout_pyxsNow, run Klayout. In the Tools menu, you should see pyxs > Load pyxs script.Linux / Mac OSRun$makeinstallNow, run Klayout. In the Tools menu, you should see pyxs > Load pyxs script.
Package: klaytnetl
Ethereum ETLEthereum ETL lets you convert blockchain data into convenient formats like CSVs and relational databases.Do you just want to query Ethereum data right away? Use thepublic dataset in BigQuery.Full documentation available here.QuickstartInstall Ethereum ETL:pip3installethereum-etlExport blocks and transactions (Schema,Reference):>ethereumetlexport_blocks_and_transactions--start-block0--end-block500000\--blocks-outputblocks.csv--transactions-outputtransactions.csv\--provider-urihttps://mainnet.infura.io/v3/7aef3f0cd1f64408b163814b22cc643cExport ERC20 and ERC721 transfers (Schema,Reference):>ethereumetlexport_token_transfers--start-block0--end-block500000\--provider-urifile://$HOME/Library/Ethereum/geth.ipc--outputtoken_transfers.csvExport traces (Schema,Reference):>ethereumetlexport_traces--start-block0--end-block500000\--provider-urifile://$HOME/Library/Ethereum/parity.ipc--outputtraces.csvStream blocks, transactions, logs, token_transfers continually to console (Reference):>pip3installethereum-etl[streaming]>ethereumetlstream--start-block500000-eblock,transaction,log,token_transfer--log-filelog.txt\--provider-urihttps://mainnet.infura.io/v3/7aef3f0cd1f64408b163814b22cc643cFind other commandshere.For the latest version, check out the repo and call>pip3install-e.>python3ethereumetl.pyUseful LinksSchemaCommand ReferenceDocumentationExporting the BlockchainQuerying in Amazon AthenaQuerying in Google BigQueryQuerying in KaggleAirflow DAGsPostgres ETLEthereum 2.0 ETLRunning Tests>pip3install-e.[dev,streaming]>exportETHEREUM_ETL_RUN_SLOW_TESTS=True
>pytest-vvRunning Tox Tests>pip3installtox
>toxRunning in DockerInstall Dockerhttps://docs.docker.com/install/Build a docker image> docker build -t ethereum-etl:latest .
 > docker image lsRun a container out of the image> docker run -v $HOME/output:/ethereum-etl/output ethereum-etl:latest export_all -s 0 -e 5499999 -b 100000 -p https://mainnet.infura.io
 > docker run -v $HOME/output:/ethereum-etl/output ethereum-etl:latest export_all -s 2018-01-01 -e 2018-01-01 -p https://mainnet.infura.ioRun streaming to console or Pub/Sub> docker build -t ethereum-etl:latest -f Dockerfile .
 > echo "Stream to console"
 > docker run ethereum-etl:latest stream --start-block 500000 --log-file log.txt
 > echo "Stream to Pub/Sub"
 > docker run -v /path_to_credentials_file/:/ethereum-etl/ --env GOOGLE_APPLICATION_CREDENTIALS=/ethereum-etl/credentials_file.json ethereum-etl:latest stream --start-block 500000 --output projects/<your-project>/topics/crypto_ethereumProjects using Ethereum ETLGoogle- Public BigQuery Ethereum datasetsNansen by D5- Analytics platform for Ethereum
Package: klaytn-etl-cli
Klaytn ETLKlaytn ETL lets you convert Klaytn blockchain data into convenient formats like JSONs, CSVs and relational databases.
This is a fork ofEthereum ETL.Full documentation available here.Notice: Klaytn ETL is still on the beta version. However, CLIs are all functional.QuickstartInstall Klaytn ETL:pip3installklaytn-etl-cliExport blocks and transactions>klaytnetlexport_blocks_and_transactions--start-block0--end-block5000\--blocks-outputblocks.json--transactions-outputtransactions.jsonExport ERC20 and ERC721 transfers>klaytnetlexport_token_transfers--start-block0--end-block5000\--outputtoken_transfers.jsonExport traces>klaytnetlexport_traces--start-block0--end-block5000\--outputtraces.jsonFind other commandshere.For the latest version, check out the repo and call>pip3install-e.>python3klaytnetl.pyRunning in DockerInstall Dockerhttps://docs.docker.com/install/Build a docker image>dockerbuild-tklaytn-etl:latest.
>dockerimagelsRun a container out of the image>dockerrun-v$HOME/output:/klaytn-etl/outputklaytn-etl:latestexport_all-s0-e5499999-b100000>dockerrun-v$HOME/output:/klaytn-etl/outputklaytn-etl:latestexport_all-s2018-01-01-e2018-01-01
Package: klaytn-etl-test
Klaytn ETLKlaytn ETL lets you convert Klaytn blockchain data into convenient formats like JSONs, CSVs and relational databases.
This is a fork ofEthereum ETL.Notice: Klaytn ETL is still on the beta version. However, CLIs are all functional.Documents about command reference will be soon updated.Please check issues to figure out current works.QuickstartInstall Klaytn ETL:pip3installklaytn-etl-cliExport blocks and transactions>klaytnetlexport_blocks_and_transactions--start-block0--end-block5000\--blocks-outputblocks.json--transactions-outputtransactions.jsonExport ERC20 and ERC721 transfers>klaytnetlexport_token_transfers--start-block0--end-block5000\--outputtoken_transfers.jsonExport traces>klaytnetlexport_traces--start-block0--end-block5000\--outputtraces.jsonFind other commandshere.For the latest version, check out the repo and call>pip3install-e.>python3klaytnetl.pyRunning in DockerInstall Dockerhttps://docs.docker.com/install/Build a docker image>dockerbuild-tklaytn-etl:latest.
>dockerimagelsRun a container out of the image>dockerrun-v$HOME/output:/klaytn-etl/outputklaytn-etl:latestexport_all-s0-e5499999-b100000>dockerrun-v$HOME/output:/klaytn-etl/outputklaytn-etl:latestexport_all-s2018-01-01-e2018-01-01
Package: klazor-client
Klazor Client PackageA package that enables client-server communication between your app and klazor serverInstallationpip install git+https://github.com/wilcoln/klazor-client.gitUsageimportklazor_clientaskckc.config(API_URL='http://127.0.0.1:8000/api',# should be 'http://klazor.com/api')# fetch item by its idcourse=kc.fetch_course(1)sheet=kc.fetch_sheet(2)# fetch all itemscourses=kc.fetch_courses()sheets=kc.fetch_sheets()ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT
Package: kld7
This is a simple, high-level interface to theK-LD7radar module. It
lets the user read and set the various radar parameters as described
in thedatasheetand fetch the various sorts of raw or processed data
frames from the sensor, either individually or as a stream.Tracking the distance, speed, angle and magnitude of the most
promenant moving object in range is as simple as:fromkld7importKLD7withKLD7("/dev/tty.usbserial")asradar:fortarget_infoinradar.stream_TDAT():print(target_info)DocumentationThe API for this module is documented onReadTheDocs.OverviewAccording the the datasheet:“The K-LD7 is a fully digital low cost Doppler radar that can
measure speed, direction, distance and angle of moving objects in
front of the sensor. The digital structure and wide power supply
range make it very easy to use this sensor in any stand-alone or
MCU based application.”The module can detect and measure multiple moving objects and provide
filtered tracking information about the most prominent one. Various
detection criteria can be stored and a set of programmable output pins
on the module can be configured to indicate detection status, allowing
for stand-alone operation once the coniguration paramters have been
set.The K-LD7 module includes an integrated signal processor and allows
access to the radar signal at a number of levels including raw ADC
samples, FFT output, candidate targets, most significant tracked
target and flags for the tracked target relative to detection
thresholds. Each level of processing provides higher-level information
and thus reduces the volume of data that needs to be sent to the host.
This driver allows users to access each of these levels of data to be
fetched, either as a single snamshot or as a stream of data frames.Configuration paramtersThe K-LD7 module has 22 configurable radar paramters that can be used
to control the sensitivity, distance and speed range and detection
thresholds used during filtering, as well as for configuring the
programmable output pins. These paramters can be read and set though
aRadarParamProxyobject accessible as theparamsattribute of the driver object.
Package: kle2netlist
kle2netlistCI/CDPackageMetaKiCad netlist generator for mechanical keyboardsInstallationpip install kle2netlistUsage$ kle2netlist --help

Usage: kle2netlist [OPTIONS]

Generates KiCad netlist for a given keyboard layout json file.

Options
--layout                    Path to kle layout file [default: None] [required]
--output-dir                Output directory, created if not existing [default: .]
--name                      Netlist name without file extension [default: keyboard]
--switch-footprint -swf     Switch footprint f-string [default: PCM_Switch_Keyboard_Cherry_MX:SW_Cherry_MX_PCB_{:.2f}u]
--stabilizer-footprint -stf Stabilizer footprint [default: PCM_Mounting_Keyboard_Stabilizer:Stabilizer_Cherry_MX_{:.2f}u]
--diode-footprint -df       Diode footprint [default: Diode_SMD:D_SOD-123F]
--lib-path -l               Path to symbol library [default: None]
--controller-circuit        Add ATmega32U4-AU minimal circuitry
--no-xml                    Skip xml netlist generation
--version -v                Prints the version of the kle2netlist package.
--help                      Show this message and exit.
Package: klear
# KLEAR v0.1BETAKlear is a simple , clean and effective way to text between teams. Text between friends or teams from the cli. Klear is built with python and only uses sockets for communication.#### Note: Klear is still in development. The developer is not responsible for any issues caused.
## InstallationUse the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.`bash pip install klear `## Run on your own server`bash python klear_server.py `By default the server is mapped on port 8081, please update the server script with a port you want to use.## Contributing
Pull requests are very much welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.## License
[MIT](https://choosealicense.com/licenses/mit/)