Saravanan666/pypi-org huggingface dataset:
Package: kisee
Kisee — Identity Provider ServerNameThe name "Kisee", inspired from "KISS" ("Keep it simple, stupid.") is
spoken as the french phrase "Qui c'est ?",[kis‿ɛ].OverviewKisee is an API giving JWTs in exchange for valid usernames/password
pairs. That's it.Kisee is better used as a backend of thePaseeidentity manager: Pasee
handle groups and can handle multiple identity backends (one or many
Kisee instances, twitter, facebook, ...).Kisee can use your existing database (or use a dedicated one) to query
the username and passwrds if you're willing to implement a simple
Python class to query it, so Kisee can query anything: LDAP, a flat
file, a PostgreSQL database with a strange schema, whatever.Quick start$pipinstallkisee
$kisee--settingsexample-settings.tomlThis starts Kisee with an in-memory demo backend, just so you can
play. The demo backend will print the admin credentials at startup:$kisee--settingsexample-settings.toml

Admincredentialsforthissessionis:
username:root
password:UGINenIU========Runningonhttp://0.0.0.0:8140========(PressCTRL+Ctoquit)So we can start by getting a JWT for the admin user (beware, your
password is different):$curl0:8140/jwt/-XPOST-d'{"username": "root", "password": "UGINenIU"}'{"_type":"document","_meta":{"url":"/jwt/","title":"JSON Web Tokens"},"tokens":["eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NiJ9.eyJpc3MiOiJleGFtcGxlLmNvbSIsInN1YiI6IkpvaG4iLCJleHAiOjE1NTMyNzQyNjEsImp0aSI6IjlXb0piV1g2OGpmQVo5N1dNRWRjNDQifQ.iYAgA-018VHQo9tWLfk7XIxtrDKYk_CTWhHXo7bMBGDz9HGKRIwV_mh0Wla6tf6z-_JH5KRTQRnQl5DLLlIelg"],"add_token":{"_type":"link","action":"post","title":"Create a new JWT","description":"POSTing to this endpoint create JWT tokens.","fields":[{"name":"username","required":true},{"name":"password","required":true}]}}It's possible for a new user to "self-register" by posting on/users/:$curl-i0:8140/users/-XPOST-d'{"username": "JohnDoe", "password": "sdfswlwl", "email": "john@example.com"}'HTTP/1.1201Created
Location:/users/JohnDoe/Read the docs:https://kisee.readthedocs.io
Package: kise-gateway-provisioners
Gateway ProvisionersGateway Provisioners provideskernel provisionersthat interact with kernels launched into resource-managed clusters or otherwise run remotely from the launching server.
This functionality derives fromJupyter Enterprise Gateway'sprocess proxyarchitecture. However, unlikeprocess proxies,
you do not need to use a gateway server to use these provisioners - although, in certain cases,
it is recommended (for example when the launching server does not reside within the same network as the launched kernel).Here is the current set of provisioners provided by this package, many of which have their requirements conditionally
installed:KubernetesProvisioner- Kernels (residing in images) are launched as pods within a Kubernetes clusterpip install gateway_provisioners[k8s]DockerSwarmProvisioner- Kernels (residing in images) are launched as containers within a DockerSwarm clusterDockerProvisioner- Kernels (residing in images) are launched as containers on the local serverpip install gateway_provisioners[docker]YarnProvisioner- Kernels are launched into a Hadoop YARN cluster (primarily Spark)pip install gateway_provisioners[yarn]DistributedProvisioner- Kernels are launched across a set of hosts using SSH, round-robinpip install gateway_provisionersThis package also includes command-line utilities that can be used to create kernel specifications or inject bootstrap
files into docker images relative to the desired provisioner:jupyter-k8s-spec- for building kernel specifications relative to theKubernetesProvisionerjupyter-docker-spec- for building kernel specifications relative toDockerProvisionerandDockerSwarmProvisionerjupyter-yarn-spec- for building kernel specifications relative to theYarnProvisionerjupyter-ssh-spec- for building kernel specifications relative to theDistributedProvisionerjupyter-image-bootstrap- for injecting bootstrap support when building kernel-based imagesNote:The container-based provisioners (KubernetesProvisioner,DockerSwarmProvisioner, andDockerProvisioner)
require that the hosting server also be running within the same environment/network. As a result, these provisioners
may be better suited for use by a Gateway Server (e.g.,Jupyter Kernel Gateway)
so as to not require the Notebook/Lab server also be deployed in a container.InstallationDetailed deployment instructions are located in theOperators Guideof the project docs. Here's a quick start usingpip:# install from pypipipinstall--upgradegateway-provisioners# options for the command-line utilities can be viewed using '--help-all'jupyteryarn-specinstall--help-all# run it with default options to install a Python-based kernelspec for Hadoop Yarnjupyteryarn-specinstallContributingTheContribution pageincludes
information about how to contribute to Gateway Provisioners. We encourage you to explore the other topics in ourContributors Guidelike how toset up a development environment,
or gaining an understanding of thesystem architecture,
among other things.
Package: kiseru
Kiseru is Japanese pipe. That's all.# Install`pip install kiseru` or `git clone git@github.com:mtwtkman/kiseru`# UsageYou can choice `class-based` or `decorator` style.# class-based-style```pythonfrom kiseru import Kiserudoggy = Kiseru(lambda: 'inu is dog')split = Kiseru(lambda x: x.split())capitalize = Kiseru(lambda x: [i[0].upper() + i[1:] for i in x])join = Kiseru(lambda x: ' '.join(x))doggy() | split | capitalize | join# => 'Inu Is Dog'```# decorator-styleThis is just a syntax sugar.```pythonfrom kiseru import kiseru@kiserudef kitten():return 'neko is cat'@kiserudef kebab(x):return '-'.join(x.split())@kiserudef does_cat_hide(x):return 'cat' in xkitten() | kebab | does_cat_hide# => True```
Package: kishu
Intelligent checkpointing framework for Python-based machine learning and scientific computing.
Under development as part of a research project at the University of Illinois at Urbana-Champaign.InstallationRun the following command in avirtual environment.python setup.py installJupyter IntegrationRun Jupyter after installing kishu. In your notebook, you can enable kishu with the following command.Basic Usagefrom kishu import init_kishu
init_kishu()Then, all the cell executions are recorded, and the result of each cell execution is checkpointed.Working with Kishuinit_kishu()adds a new variable_kishu(of type KishuJupyterExecHistory) to Jupyter's namespace.
The special variable can be used for kishu-related operations, as follows.Browse the execution log._kishu.log()See the database file._kishu.checkpoint_file()Restore a state._kishu.checkout(commit_id)Checkpoint BackendDeploy a restful server.flask --app kishu/backend runDeploymentThe following command will upload this project to pypi (https://pypi.org/project/kishu/).bash upload2pypi.sh
Package: kishuboard
KishuBoardThis is a dash-board extension of Kishu. With the interactive GUI provided by KishuBoard, you can browse, compare and search commits, checkout code/kernel variables to previous commits; branch out etc in a straightforward way.Getting Startedpypi installationTo install the extension from pypi, execute:pipinstallkishuboardTo remove the extension, execute:pipuninstallkishuboardstarting up via kishuboardkishuboardAnd then you should be able to  visit the kishuboard at localhost://5000.Install from source code:Note: You will need NodeJS to build the kishuboard, please make sure you have node on your computer, or install it fromhere.enter the directory of the current filebuild the NodeJS frontendnpminit# If you are building it from the source code for the first timenpminstall# If you are building it from the source code for the first timenpmrunbuild[optional] Install kishu core from source codesource../.env/bin/activate# activate the virtual environmentpipinstall../kishu# install kishu from source codepipinstall-rrequirements.txt#install other dependenciesinstall kishu boardpipinstall.run the kishuboardkishuboardAnd then you should be able to  visit the kishuboard at localhost://5000.DevelopmentDev mode deploymentTo run the kishuboard in dev mode, you will need to start the kishuboard server and the kishuboard frontend separately.enter the directory of this readme filestart the kishuboard server(backend) in dev modesource../.env/bin/activate# activate the virtual environmentcdkishuboard
flask--appserverrunstart the kishuboard frontend in dev modecd..# go back to the directory of this readme filenpminit# If you are building it from the source code for the first timenpminstall# If you are building it from the source code for the first timenpmstartAnd you should be able to visit the kishuboard atlocalhost://3000.ReleaseTo build a new release of kishuboard, please refer toRELEASE.md
Package: kishw
kishwCustom widget libraryThis extension is composed of a Python package namedkishwfor the server extension and a NPM package namedkishwfor the frontend extension.RequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstallkishwUninstallTo remove the extension, execute:pipuninstallkishwTroubleshootIf you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:jupyterserverextensionlistIf the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:jupyterlabextensionlistContributingDevelopment 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 kishw directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenablekishw# 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 uninstall# Server extension must be manually disabled in develop modejupyterserverextensiondisablekishw
pipuninstallkishwIn 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 namedkishwwithin that folder.Testing the extensionServer testsThis extension is usingPytestfor Python code testing.Install test dependencies (needed only once):pipinstall-e".[test]"To execute them, run:pytest-vv-rap--covkishwFrontend 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: kismet-analyzer
This library can be used to analyze the results of the new Kismet version. To filter encryption typesKismetversion "f07735c" (Aug 19, 2018) or later is required.The following scripts will be installed:kismet_analyzer_aplist:This script can be used to extract access points from the SQLite database.kismetand export these results tocsvandkml.kismet_analyzer_clientlistThis script can be used to create a list of connected clients for a given SSID. The list is printed to stdout with one client mac per row.kismet_analyzer_devicesThis script can be used to extract a list of discovered devices. The result can be exported tocsvandkml.LicenseThis script is licensed under the GNU General Public License in version 3. Seehttp://www.gnu.org/licenses/for further details.Installation:Installation via pippip install kismet-analyzerManual installation from this repositoryThis library requiressimplekmlfor exporting extracted information tokml. You can usepipto install the neccessary requirement.pip install -r requirements.txtThe setup script can be used to install the library and requirements. It will create the above listed console commands.python setup.py installUsage:(venv)[kismet-analyzer]$ kismet_analyzer_aplist -h
usage: kismet_analyzer_aplist [-h] --in INFILE [--out OUTFILE] [--title TITLE]
                              [--ssid SSID] [--exclude-ssid EXCLUDESSID]
                              [--strongest-point] [--encryption ENCRYPTION]
                              [--csv] [--kml] [--verbose]

Kismet to KML Log Converter

optional arguments:
  -h, --help            Show this help message and exit
  --in INFILE           Input file (.kismet) 
  --out OUTFILE         Output filename (optional)
  --title TITLE         Title embedded in KML file
  --ssid SSID           Only plot networks which match the SSID (or SSID
                        regex)
  --exclude-ssid EXCLUDESSID
                        Exclude networks which match the SSID (or SSID
                        regex)
  --strongest-point     Plot points based on strongest signal
  --encryption ENCRYPTION
                        Show only networks with given encryption type
  --csv                 Export results to csv
  --kml                 Export results to kml
  --verbose             Print MAC, SSID, encryption type to stdoutExport only access points with encryption type "Open" to csv and kml files:kismet_analyzer_aplist --in input.kismet --out test --encryption "Open" --kml --csv 
Exported 11 devices to test.csv
Exported 11 devices to test.kmlOutput example for kml exportsThe script generates colored notes for exported access points. The color depends on the identified encryption type. WPA encrypted access points will be added with a green color, WEP encrypted networks will be displayed in orange and Open network are displayed in red. Networks were the encryption type could not be detected will be added as a yellow note. Each note contains detailed meta information about the access point (SSID, MAC address, frequency, channel, manufacturer, and a list of clients MAC addresses).
Package: kismet-rest
kismet_restPython wrapper for Kismet REST interface.Installing from PyPIpip install kismet_restInstalling from sourcegit clone https://github.com/kismetwireless/python-kismet-rest
cd python-kismet-rest && pip install .Usage examplesLegacy functionality (KismetConnector):import kismet_rest
conn = kismet_rest.KismetConnector(username="my_user", password="my_pass")
for device in conn.device_summary():
    pprint.pprint(device)Alerts since 2019-01-01:import kismet_rest
alerts = kismet_rest.Alerts()
for alert in alerts.all(ts_sec=1546300800):
    print(alert)Devices last observed since 2019-01-01:import kismet_rest
devices = kismet_rest.Devices()
for device in devices.all(ts=1546300800):
    print(device)Developer notes:Formatting commit messages:
* Correctly-formatted commit messages will be organized in CHANGELOG.rst
* Commit messages are formatted like thistype: audience: message !tag* Type is for the type of change (new,chg)
* Audience is for the audience of the commit note(usr,``test``,``doc``)
* The message part is pretty self-explanatory.
* The optional tag allows you to flag a commit for exclusion from CHANGELOG.rst.(minororwip)
* A commit message like this:new: usr: Made a new widget.will appear in CHANGELOG.rst, under the appropriate release, under the “New” section.
* More info on message formatting:https://github.com/vaab/gitchangelogUpdating CHANGELOG.rst:
* Install gitchangelog:pip3 install gitchangelog* Make sure that__version__is correct inkismet_rest/__init__.py* Build the new changelog:gitchangelog > CHANGELOG.rstChangelogv2020.05.01ChangesAdd support for datasource open/close [ohad83]Switch to itjson endpoints [Mike Kershaw / Dragorn]v2019.05.02ChangesSupport Python 3.5. [ashmastaflash]Add MANIFEST.in. [ashmastaflash]2019.05.01 (2019-05-20)NewRefactor complete. [ashmastaflash]Closes #1ChangesAdd developer notes to README.rst. [ashmastaflash]Add configs for gitchangelog and rtd. [ashmastaflash]OtherUpdate docs. [Mike Kershaw / Dragorn]Start extracting module. [Mike Kershaw / Dragorn]Started repo. [Mike Kershaw / Dragorn]
Package: kiss
kiss is a Python Module that implementations theKISS Protocolfor
communicating with KISS-enabled devices (such as Serial or TCP TNCs).Versions6.5.x branch will be the last version of this Module that supports Python 2.7.x7.x.x branch and-on will be Python 3.x ONLY.InstallationInstall from pypi using pip:pip install kissUsage ExamplesRead & print frames from a TNC connected to ‘/dev/ttyUSB0’ at 1200 baud:import kiss

def p(x): print(x)  # prints whatever is passed in.

k = kiss.SerialKISS('/dev/ttyUSB0', 1200)
k.start()  # inits the TNC, optionally passes KISS config flags.
k.read(callback=p)  # reads frames and passes them to `p`.See also: examples/ directory.TestingRun nosetests from a Makefile target:make testSee AlsoPython APRS ModuleLibrary for sending, receiving and parsing APRS Frames to and from multiple InterfacesPython KISS ModuleHandles interfacing-to and encoding-for various KISS Interfaces.Python APRS GatewayUses Redis PubSub to run a multi-interface APRS Gateway.Python APRS TrackerTK.dirusDirus is a daemon for managing a SDR to Dire Wolf interface. Manifests that interface as a KISS TCP port.Similar Projectsapexby Jeffrey Phillips Freeman (WI2ARD). Next-Gen APRS Protocol. (based on this Module! :)aprslibby Rossen Georgiev. A Python APRS Library with build-in parsers for several Frame types.aprxby Matti & Kenneth. A C-based Digi/IGate Software for POSIX platforms.dixprsby HA5DI. A Python APRS project with KISS, digipeater, et al., support.APRSDroidby GE0RG. A Java/Scala Android APRS App.YAACby KA2DDO. A Java APRS Client.Ham-APRS-FAPby aprs.fi: A Perl APRS Parser.Dire Wolfby WB2OSZ. A C-Based Soft-TNC for interfacing with sound cards. Can present as a KISS interface!Build StatusMaster:Develop:SourceGithub:https://github.com/ampledata/kissAuthorGreg Albrecht W2GMDoss@undef.nethttp://ampledata.org/CopyrightCopyright 2017 Greg Albrecht and ContributorsAutomatic Packet Reporting System (APRS)is Copyright Bob Bruninga WB4APRwb4apr@amsat.orgLicenseApache License, Version 2.0. See LICENSE for details.
Package: kiss2
kiss2 - Python KISS Module*************************kiss2 is a Python Module that implementations the `KISS Protocol <https://en.wikipedia.org/wiki/KISS_(TNC)>`_ forcommunicating with KISS-enabled devices (such as Serial or TCP TNCs). It is based on kiss(Another python module) which is no longer maintained.Versions========- 6.5.x branch will be the last version of this Module that supports Python 2.7.x- 7.x.x branch and-on will be Python 3.x ONLY.Installation============Install from pypi using pip: ``pip install kiss2``Usage Examples==============Read & print frames from a TNC connected to '/dev/ttyUSB0' at 1200 baud::import kissdef p(x): print(x)  # prints whatever is passed in.k = kiss.SerialKISS('/dev/ttyUSB0', 1200)k.start()  # inits the TNC, optionally passes KISS config flags.k.read(callback=p)  # reads frames and passes them to `p`.See also: examples/ directory.Testing=======Run nosetests from a Makefile target::make testSimilar Projects================* `apex <https://github.com/Syncleus/apex>`_ by Jeffrey Phillips Freeman (WI2ARD). Next-Gen APRS Protocol. (based on this Module! :)* `aprslib <https://github.com/rossengeorgiev/aprs-python>`_ by Rossen Georgiev. A Python APRS Library with build-in parsers for several Frame types.* `aprx <http://thelifeofkenneth.com/aprx/>`_ by Matti & Kenneth. A C-based Digi/IGate Software for POSIX platforms.* `dixprs <https://sites.google.com/site/dixprs/>`_ by HA5DI. A Python APRS project with KISS, digipeater, et al., support.* `APRSDroid <http://aprsdroid.org/>`_ by GE0RG. A Java/Scala Android APRS App.* `YAAC <http://www.ka2ddo.org/ka2ddo/YAAC.html>`_ by KA2DDO. A Java APRS Client.* `Ham-APRS-FAP <http://search.cpan.org/dist/Ham-APRS-FAP/>`_ by aprs.fi: A Perl APRS Parser.* `Dire Wolf <https://github.com/wb2osz/direwolf>`_ by WB2OSZ. A C-Based Soft-TNC for interfacing with sound cards. Can present as a KISS interface!Source======Github: https://git.scd31.com/laptopdude90/kiss2Author======Greg Albrecht W2GMD oss@undef.net (kiss)Stephen Downward VA1QLE stephen@stephendownward.ca (kiss2)https://blog.scd31.comCopyright=========Copyright 2017 Greg Albrecht(kiss), Stephen Downward(kiss2) and ContributorsLicense=======Apache License, Version 2.0. See LICENSE for details.
Package: kiss3
kiss3 is a Python Module that implements theKISS Protocolfor
communicating with KISS-enabled devices (such as Serial or TCP TNCs)
and provides support for encoding and decoding AX.25 frames.Versions8.x branch frompython-aprsaskiss3, supports python 3.6+Previous versions were released byampledataaskiss:7.x.x branch and-on will be Python 3.x ONLY.6.5.x branch will be the last version of this Module that supports Python 2.7.xInstallationInstall from pypi using pip:pip install kiss3Usage ExamplesRead & print frames from a TNC connected to ‘/dev/ttyUSB0’ at 1200 baud:import kiss

def p(x): print(x)  # prints whatever is passed in.

k = kiss.SerialKISS('/dev/ttyUSB0', 1200)
k.start()  # inits the TNC, optionally passes KISS config flags.
k.read(callback=p)  # reads frames and passes them to `p`.See also: examples/ directory.TestingRun tox:toxSee AlsoPython APRS ModuleLibrary for sending, receiving and parsing APRS Frames to and from multiple InterfacesPython KISS ModuleHandles interfacing-to and encoding-for various KISS Interfaces.Python APRS GatewayUses Redis PubSub to run a multi-interface APRS Gateway.Python APRS TrackerTK.dirusDirus is a daemon for managing a SDR to Dire Wolf interface. Manifests that interface as a KISS TCP port.Similar Projectsapexby Jeffrey Phillips Freeman (WI2ARD). Next-Gen APRS Protocol. (based on this Module! :)aprslibby Rossen Georgiev. A Python APRS Library with build-in parsers for several Frame types.aprxby Matti & Kenneth. A C-based Digi/IGate Software for POSIX platforms.dixprsby HA5DI. A Python APRS project with KISS, digipeater, et al., support.APRSDroidby GE0RG. A Java/Scala Android APRS App.YAACby KA2DDO. A Java APRS Client.Ham-APRS-FAPby aprs.fi: A Perl APRS Parser.Dire Wolfby WB2OSZ. A C-Based Soft-TNC for interfacing with sound cards. Can present as a KISS interface!SourceGithub:https://github.com/ampledata/kissAuthorsGreg Albrecht W2GMDoss@undef.nethttp://ampledata.org/Masen Furer KF7HVMkf7hvm@0x26.netCopyrightCopyright 2022 Masen Furer and ContributorsCopyright 2017 Greg Albrecht and ContributorsAutomatic Packet Reporting System (APRS)is Copyright Bob Bruninga WB4APRwb4apr@amsat.orgLicenseApache License, Version 2.0. See LICENSE for details.
Package: kisscartoon-api
KissCartoon APIThis is unofficial API forkisscartoon.iowebsite.
It’s written for Python 3, tested on Python3.6 and Python3.4InstallationThe package is on Pypi, so you can install it simply withpip installkisscartoon-apiUsageInstructions for use can be found at the webpage of full documentation:kisscartoon-api.rtfd.orgExample of use>>> from KissCartoon import *
>>> kiss_list = KissCartoon().search('brickleberry')
>>> for series in kiss_list:
...     print(series)
...
Brickleberry Season 01
Brickleberry Season 03
Brickleberry Season 02