Saravanan666/pypi-org huggingface dataset:
Package: leanix-az-py
LeanIX Python Library for AzureThis package provides two basic functions used during the development of every Azure Function.This package contains :#auth:  For authentication-getBearerToken(base_url, api_token) returns the authentication header#graphql: For managing GraphQL stuff.-runGraphql(header, json_data) runs the given graphql queryTODO:-LOTSUseageExample:
from leanixpy_az import graphql  

graphql.runGraphql(<Header>, <Query>)
Package: leanix-py
LeanIX Python LibraryForked from leanix-public/leanix-python-libraryCurrently very basic functionality.LeanIX Class will do your authentication and token management.  It will return an object with a number of subclasses:#graph: A class for managing GraphQL stuff.-execGraphQL(query,variables) - Executes GraphQL, returns raw HTTP Response object
-execGraphQLParsed(query,variables) - same as above, but returns a dict with the JSON of the response parsed out
-execGraphQLTrimmed(query,variables) - Same, as parsed, but removes the superfluous "edge" and "node" levels in the dict#factsheets: A class for working with factsheets-create(name*,fstype*,attributes,validateOnly)-creates a factsheet. Attributes is a dict with key/value pairs for attribs like "/alias":"Alias to add". validateOnly defaults to "false", but you can send a create to only test.
-update(fsid*,attributes*,comment*,validateOnly)
-delete(fsid*,comment*,validateOnly)
-deleteByNameAndType(name*,fstype*,comment*,validateOnly)
-getByContainsName(name*) - Returns multiple factsheets that conain the string in name
-getFactSheetByNameAndType(name*,fstype*) - returns a dict with Factsheet info by name and type - exact match only
-getIdByNameAndType(name*,fstype*) - returns a single id as a string from query
-getAllByType(fstype*) - returns all factsheets of a specific type#users:  A class for working with usersgetUsers:  Gets all users into a list
getUsersEmail:  Gets all users into a dict with a key of the user's e-mail address
getUserByEmail: Gets a single user based on e-mail
getUsersID:  Gets all users into a dict with a key of the user's Account ID (GUID)
getUserByID: Gets a single user by ID
setRole:  Sets a user's role by e-mail. Roles are ADMIN,MEMBER,VIEWER, and CONTACTTODO:LOTS!Useagefrom LeanIX import LeanIX  

lix = LeanIX(api_token=api_token,workspaceid=workspaceid,baseurl=baseurl)  

# There are three functions available to execute GraphQL against the LeanIX endpoint.   
raw = lix.graph.execGraphQL(<query>,<vars>)  # Returns the raw HTTP Response object for you to interpret  
parsed = lix.graph.execGraphQLParsed(<query>,<vars>) # Reads the response JSON and returns a dict  
trimmed = lix.graph.execGraphQLTrimmed(<query>,<vars>) # Takes the "parsed" output and remives the "edges" and "nodes" levesl from the dict
Package: lean-manufacturing
Lean manufacturing for PythonUse lean manufacturing concepts to optimize python workflow.Organize and access your workflow through a mongodb local installation.Make your relevant functions independent from each other.Configure your functions through mongodb while your scripts are running.Measure setup duration, process duration and lead time.Monitor the status of each worker in real time.Schedule running times and periodsThe lean principles behind itDefine value for the customerDetermine the value stream for each productCreate a free flow of materials and a backwards flow of informationImplement a pull system in the costumer-supplier relationshipContinously pursue perfection in the processGeneral conceptRequirementsYou'll need a localhost default installation of the community version of MongoDb (i.e. accessible atmongodb://localhost:27017).This is a great and easy-to-use database, completely free. Please seehttps://www.mongodb.com/docs/manual/installation/if you need help with the installation.Not required, but usefulMongodb Compass is a free software from mongodb that allows you to visually edit your mongodb databases. Please seehttps://www.mongodb.com/products/compassif you want to download it.UsageSyntax@Lean.value_stream(
    value_stream,
    supplier = <dict>,
    client   = <dict>,
    schedule = <str>
)

supplier = {
    list: <list>        # for supplier as list, instead of db values
    uri: <str>,         # for remote connection only
    db:  <str>,         # for remote connection only
    collection: <str>,
    unique: <str>,
    aggregation: <list>,
    order: <int>,
    regex: <str>,
    gt: <int>,
    content: ['@all', '@inventory', '@supplier', '@existing'],
}

client = {
    uri: <str>,         # for remote connection only
    db:  <str>,         # for remote connection only
    collection: <str>,  # for remote connection only
    unique: <str>,
    update: <boolean>
}

schedule: <str> # choose from '@hourly', '@daily', '@weekly', '@monthly', '@annually'Getting the input from a supplier remote mongodb installation@Lean.value_stream('my_value_stream',
    supplier={
        uri: 'your mongodb uri',
        db: 'db_name',
        collection: 'collection_name',
        aggregation: [{'$project': {'_id': 0}}],
        unique: 'field_a'
    },
    client={
        unique: 'field_b'
    }
)

def my_first_process(input, **config):
    
    # do something with input
    output = [element for element in input]

    return outputGetting the input from another supplier process@Lean.value_stream('my_value_stream',
    supplier={
        collection: 'my_value_stream.my_first_process',
        unique: 'field_b'
    },
    client={
        unique: 'field_c'
    }
)

def my_other_process(input, **config):

# do something with input
output = [element for element in input]

return outputUpdates1.7Registers availability by the minute.1.8Syntax improvement
Package: leanpub
# leanpub cliBuild leanpub books locally from the command line.> Note/Disclaimer: This is not an official Leanpub product, it simply uses
> pandoc to build a pdf from markdown in a similar way to Leanpub. Currently
> the output from leanpubis differentin style (and this will probably
> always be the case), however I find that it massively speeds up the iteration
> process to be able to build a pdf which looks “similar enough” to Leanpub.This implements a simple cli for building ebooks locally. Rather than having
upload your new change-set to Dropbox and then trigger leanpub build on
their site - do it all locally.## UsageTo build the Book (this requires aBook.txt):`sh $ leanpub book `To build the Sample (this requires aSample.txt):`sh $ leanpub sample `To build both:`sh $ leanpub all `You can also “watch” for changes in any of the markdown files you are using to
build the book i.e. when a markdown file is saved:`sh $ leanpub watch `You can get help via the command line with:`sh $ leanpub--help`## InstallationInstall via [pip](https://pip.pypa.io/en/latest/installing.html):`sh $ pip install leanpub `Note: if you don’t have python installed I recommend
[miniconda](http://conda.pydata.org/miniconda.html); no-admin access required.This requires that pandoc is installed, if it’s not install it
[here](http://pandoc.org/installing.html).## Issues / troubleshooting / requestsPlease post an [issue on github](https://github.com/hayd/leanpub).### Going forwardI would like to improve the output to better match leanpub.
Any help it that direction (e.g. css, or prepending the title page) would be
great!
Package: leaone-ble
leaone-bleDocumentation:https://leaone-ble.readthedocs.ioSource Code:https://github.com/bluetooth-devices/leaone-bleBluetooth parser for LeaOne devicesInstallationInstall this via pip (or your favourite package manager):pip install leaone-bleContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCopierand thebrowniebroke/pypackage-templateproject template.
Package: leap
leap describes both implicit and explicittime stepping methods. Methods are
described using a small virtual machine whose statements can
then be used to either generate code or simply execute the time
integrator.Execution and code generation is provided bydagrt. Further
supported operations include finding of stability regions, building
of companion matrices, and more.leap is licensed under the MIT license.leap requires Python 2.6 or newer.Resources:Documentationsource code via git
Package: leap.auth
This library can be used to authenticate and manage passwords in aLEAPplatform.
It uses theSecure Remote Password protocol.To install it:$pipinstallleap.authTo use it:fromleap.authimportSRPAuthapi_uri='https://api.leap.platform:4430/'ca_cert_path='./path_to_certificate.crt'# TIP: the certificate is usually at https://api.leap.platform/ca.crtuser='username'password='longandsecurepassword'srp_auth=SRPAuth(api_uri,ca_cert_path)# register a usersrp_auth.register(user,password)# authenticate with the defined LEAP server using the registered credentialsauth=srp_auth.authenticate(user,password)# then you can access:auth.usernameauth.session_idauth.uuidauth.token# changes the authenticated user password using the authentication datasrp_auth.change_password(username,current_password,new_password,auth.token,auth.uuid)# deletes the session on the server and resets the session locallysrp_auth.logout()
Package: leap.bitmask
BitmaskYour internet encryption toolkitBitmaskis the client for the services offered bythe LEAP Platform. It
contains a command-line interface and a multiplatform desktop client. It can be
also used as a set of libraries to communicate with the different services from
third party applications.It is written in python usingTwistedand licensed under theGPL3. The
Graphical User Interface is written in html+js and usesPyQt5for serving
the application.Package under development!The previous client using PySide has been deprecated (Bitmask version 0.9.2,
still available at thehttp://github.com/leapcode/bitmask_clientrepo).Read the Docs!There is documentation about Bitmaskfor usersandfor developers.BugsPlease report any bugsin our bug tracker.LogsIf you want to watch the logs, from the command line:bitmaskctl logs watchThe paste command can be handy to do bug reports (needspastebinitinstalled
in the system):bitmaskctl logs sendDevelopmentRunning TestsYou need tox to run the tests. If you don’t have it in your system yet:pip install toxAnd then run all the python tests:toxThere are some minimal end-to-end tests:make test_e2eFor testing the UI (akabitmask-js) you need to havemochainstalled. You can run ui tests like this:cd ui && make testMore info abou testing can be found in thedocs/hacking/testingdocument.HackingIn order to run bitmask in a development environment, you must activate a
virtualenv and install the various packages usingpip install -e. This
installs python packages as links to the source code, so that your code
changes are immediately reflected in the packages installed in the
virtualenv.The variousmakedev-*commands will run the appropriatepip installcommands for you.If you want to setup your whole development environment, and you are running a
debian-based system, you can try:make dev-bootstrapTo upgrade regularly the python dependencies installed inside your virtualenv,
you can run:make upgrade-allinside your virtualenv, and it will install any new version of your
dependencies that is found in pypi.Check out thedocs/hackingsections for more extense instructionsto get
you started.LicenseBitmask is released under the terms of theGNU GPL version 3or later.
Package: leap.bonafide
Bonafide is the protocol for secure user registration, authentication, and provider discovery for the LEAP
applications. See theBonafidedesign docs.This is a client implementation, written in python. It consists of a python library, a
twisted service and a command-line interface to interact locally with it.UsingThis is still in development. To play with it, create a virtualenv, and deploy
the package in development mode by running:python setup.py developfrom the parent folder.To run the bonafide service, you can use the bitmask.core daemon. From an
environment in which you have installed the bitmask_core repo:bitmaskdThen you can usebitmask_clito see the available actions, under the user
command.
Package: leapchain
OverviewPython library for leapchain digital currency.This library contains all of the core logic, shared functionality, and
constants used by both theBankandValidatoron leapchain network.Project SetupFollow the steps below to set up the project on your environment. If you run into any problems, feel free to leave a
GitHub Issue or reach out to any of our communities above.Install required packages:pip3 install -e .TestingTo run tests:pytestTo run tests with coverage report:pytest --cov-config=.coveragerc --cov=./srcTo run linting:flake8 .BuildingThe building and publishing of this package is automated through GitHub actions. To publish a new release, update the./src/leapchain/__init__.pyfile with the latest version number. The updated package will be published once the
branch is merged intomaster.To produce a source distribution manually:python3 setup.py sdistLicenseleapchain isMIT licensed.
Package: leap-client
Desktop Client for the LEAP Platform.
LEAP (LEAP Encryption Access Project) develops a multi-year plan to secure everyday communication, breaking downinto discrete services, to be rolled out one at a time.
The client for the current phase gives support to the EIP Service.EIP (the Encrypted Internet Proxy) provides circumvention, location anonymization, and traffic encryption in a hassle-free, automatically self-configuring fashion, and has an enhanced level of security.
Package: leapdna
👩‍🔬 leapdna.pyAn implementation of the leapdna toolkit in Python.Installationleapdna is compatible with Python 3.9 and greater. Install it from PyPI withpip install leapdnaUsageWorking with dataleapdna aims to provide a way to represent a lot of the data that is normally dealt with in genetics, with a focus on forensic applications. The usual suspects here are loci, alleles, profiles, allele frequency studies... All of these are represented in leapdna by a block. A block is a Python class which can be stored as a JSON file with the leapdna format. All blocks inherit from theBaseblock class and define some attributes and functionality of their own. For instance, aLocusblock has anameattribute, in addition to abandattribute, which specifies thechromosome bandwhere the locus is. OtherLocusblocks will have different values for these attributes while other types of blocks, such asAllele, will have a different set of attributes altogether. The documentation details which attributes are supported (and sometimes required) for a particular block type.fromleapdna.blocksimportAllele,Locusl1=Locus('L1')a1=Allele(name='a1',locus=l1)leapdna aims to be extensible, so it allows you to specify your own attributes in any kind of block. If you wanted to mark a locus as a potential carrier of a diseas you could dol1.user['carrier']=TrueTestingTo run the leapdna test suite executepython3-munittestfrom the root of the leapdna repository.In addition, leapdna comes with type annotations which allows for running it through a type checker such asmypy. This can be done by executingmypy leapdnafrom the root of the repository. If you do not havemypyinstalled you may do so withpython3 -m pip install mypy.LicenseCopyright 2021 Elias HernandisLeapdna is free and open-source sofware released under theMIT License. Everyone is free to copy, modify and redistribute the sofware, even for commercial purposes. While no attribution is required, it is very much appreciated. The full text of the license is availablehere.
Package: leapfrogai
LeapfrogAI SDKDescriptionHome of thePyPI LeapfrogAI SDK.Testingmakerequirements-dev
python3-mpipinstall-e.
maketestBuildingleapfrogaiand updating PyPiFirst change the version inpyproject.tomlpython3-mpipinstall--upgradebuildhatchlingtwine
python3-mbuild
python3-mtwineuploaddist/*
Package: leapimport
LeapMotion ImporterSimple package to import binary LeapMotion recording data.Free software: MIT licenseCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.2.0 (2016-09-13)Include frame_id and hand_id in dataframeUse boolean type foris_rightinstead of string0.1.2 (2016-08-30)Fix crash on some multiple hands frames0.1.1 (2016-08-23)Fix release on PyPI.0.1.0 (2016-08-23)First release on PyPI.
Package: leap.mail
Mail services for the LEAP Client.More info:https://leap.serunning testsUse trial to run the test suite:trial leap.mail… and all its goodies. To run all imap tests in a loop until some of them
fails:trial -u leap.mail.imapRead thetrialmanpage for more options .imap regressionsFor testing the IMAP server implementation, there are a couple of utilities.
From theleap.mail.imap.testsfolder, and with an already initialized server
running:./regressions_mime_struct user@provider pass path_to_samples/You can find several message samples in theleap/mail/testsfolder.0.4.1 - 18 Apr, 2016Features#7656: Emit multi-user aware events.#4008: Add token-based authentication to local IMAP/SMTP services.#7889: Use cryptography instead of pycryptopp to reduce dependencies.#7263: Implement local bounces to notify user of SMTP delivery errors.Use twisted.cred to authenticate IMAP/SMTP users.Verify plain text signed email.Validate signature with attachments.Use fingerprint instead of key_id to address keys.Bugfixes#7861: Use the right succeed function for passthrough encrypted email.#7898: Fix IMAP fetch headers#7977: Decode attached keys so they are recognized by keymanager.#7952: Specify openssl backend explicitely.Fix the get_body logic for corner-cases in which body is None (yet-to-be synced docs, mainly).Let the inbox used in IncomingMail notify any subscribed Mailbox.Adds user_id to Account (fixes Pixelated mail leakage).MiscChange IMAPAccount signature, for consistency with a previous Account change.
Package: leap.pixelated
Pixelated User Agent Service============================This is the service for the Pixelated User Agent. The primary purpose of this is to provide an interface for the user agent to communicate with the Pixelated Provider.The user agent is implemented in Python, for compatibility with the LEAP libraries. Another goal of the User Agent Service will be to run well on all major client platforms. Finally, the main goals are to have strong search, encryption and signing. However, we want to push most of these features back to LEAP so that Bitmask can leverage them as well.Development environment---* Install virtualenv:```easy_install virtualenv```* Create a virtualenv:```virtualenv .virtualenv```* Activate your virtualenv:```source .virtualenv/bin/activate```* Configure the applicationYou will need an account in a LEAP provider. Once you have it, modify the service/pixelated.example file and move it to ~/.pixelatedYou might need to add your LEAP provider ssl certificate inside the pixelated/certificates named as your provider domain name, for example:```your.leapprovider.org.crt```* Start the developer mode```./go develop --always-unzip```* To run tests:```./go test```* To run app (after starting the developer mode):```pixelated-user-agent```* For development purposes you can also copy the pixelated.example file and fill in your credentials,that way you avoid having to enter your test credentials everytime:```pixelated-user-agent --config=<config_file_path>```Run a single unit or integration test```trial```Run a single functional test```behave test/functional/features/name_of_feature.feature```
Package: leappto
LeApp is a “Minimum Viable Migration” utility that aims to
decouple virtualized applications from the operating system
kernel included in their VM image by migrating them into
macrocontainers that include all of the traditional components
of a stateful VM (operating system user space, application
runtime, management tools, configuration files, etc), but
use the kernel of the container host rather than providing
their own.This approach to migration doesnotimmediately take
advantage of all of the potential usability and
maintainability benefits offered by modern autoscaling
platforms, but may be sufficient to allow legacy
applications to be migrated and legacy hosting services
to be discontinued.InstallationInstallation is currently only supported as part of
the LeApp Cockpit plugin demo or the LeApp integration
tests.
Package: leap-second-client
It answers the following questions:What is the current difference between TAI and UTC?When was the last leap second?When is the next leap second?UsageAs a library:>>> from leap_second_client import request_leap_second_info
>>> request_leap_second_info()
LeapSecondInfo(TAI_UTC=36,
               last_leap_second=datetime.date(2015, 6, 30),
               next_leap_second=None)Or as a command-line client (greppable json output):$ python -m leap_second_client
{
    "TAI_UTC": 36,
    "last_leap_second": "2015-06-30",
    "next_leap_second": null
}It gives the current value of TAI-UTC in (integer) seconds, the date
of the last leap second and the date of the next leap second. If no
leap second is scheduled, then the value is None. The webservice
relies on the information of the last Bulletin C and the current date.Seehttp://hpiers.obspm.fr/eop-pc/index.php?index=webserviceInstallationNo dependencies except Python itself and the webservice.
To install, justdownload leap_second_client.pyor run:$ pip install leap_second_clientSupport: Python 2.6+, Python 3.License: MIT
Package: leapseconds
leapsecondsleapsecondsis a Python library with data on official leap seconds, provided as a
tuple of Unix timestamps.Source data:https://www.ietf.org/timezones/data/leap-seconds.listInstallationpip install leapsecondsUsagefromleapsecondsimportLEAP_SECONDS# Check if a Unix timestamp represents an officially announced leap second:if63072000inLEAP_SECONDS:print("True")LEAP_SECONDS:Atupleof Unix timestamps (int) that represent officially announced leap
seconds in chronological order.Licenseleapsecondsis distributed under the terms of theMITlicense.
Package: learn2clean
CompatibilitiesIt is compatible with:Python 3.6. &64-bit version only(32-bit python is not supported)Operating system:MacOSPreparationFirst, make sure you havesetuptoolsinstalled. Check that the following requirements are installed:gcc$sudoapt-getinstallbuild-essentialcmake$pipinstallcmakeInstallationInstall from pipLearn2clean is now available onPyPI, so you only need to run the following command:$pipinstalllearn2cleanInstall from the GithubThe sources for Learn2clean can be downloadedfrom theGithub repo.You can either clone the public repository:$gitclonegit://github.com/LaureBerti/Learn2CleanOr download thetarball:$curl-OLhttps://github.com/LaureBerti/Learn2Clean/tarball/masterOnce you have a copy of the source,you can install itusing setup.py :$cdlearn2clean/$pythonsetup.pyinstall