Saravanan666/pypi-org huggingface dataset:
Package: lalib
lalib- A library to study linear algebraThe goal of this project is
to create a library written solely in corePython(incl. thestandard library)
to learn aboutlinear algebra.Contributing & DevelopmentLocal Develop EnvironmentGet a copy of this repository:git clone git@github.com:webartifex/lalib.gitWhilelalibcomes without any dependencies except core Python
and the standard library for the user,
we assume a couple of mainstream packages to be installed
to ensure code quality during development.
These can be viewed in thepyproject.tomlfile.To replicate the project maintainer's develop environment,
install the pinned dependencies from thepoetry.lockfile
with thepoetrydependency manager:poetry installThis automatically creates and uses avirtual environment.Testing & Maintenance TasksWe usenoxto run the test suite
in an isolated environment
and to invoke the prepared maintenance tasks during development
(noxis quite similar totox).
It is configured in thenoxfile.pyfile.To list all available tasks, called sessions innox, simply run:poetry run nox --listTo execute all sessions that the CI server would run, invoke:poetry run noxThat runs the test suite for all supported Python versions.Code Formatting & LintingWe followGoogle's Python Style Guideand includetype hintswhere possible.During development,poetry run nox -s formatandpoetry run nox -s lintmay
be helpful.The first task formats all source code files withautoflake,black, andisort.blackkeeps single quotes'unchanged to minimize visual noise
(single quotes are enforced bywemake-python-styleguide; see next).The second task lints all source code files withflake8,mypy, andpylint.flake8is configured with a couple of plug-ins,
most notablywemake-python-styleguide.You may want to install the localpre-commithooks
that come with the project:poetry run nox -s init-projectThat automates the formatting and linting before every commit.
Also, the test suite is run before every merge.Branching StrategyThe branches in this repository follow theGitFlowmodel.
It is assumed that a feature branch is rebasedbeforeit is merged intodevelop.
Whereas after a rebase a simple fast-forward merge is possible,
all merges are made with explicit andemptymerge commits
(i.e., the merge itself doesnotchange a single line of code).
This ensures that past branches remain visible in the logs,
for example, withgit log --graph.
Package: lalistadesinde.portlet
Install the product as described in INSTALL.txtGo to the place of your site where you want to add a portlet
and click on Manage Portlets.Select “Classic portlet” in the “Add portlet…” dropdown.Enter “lalistadesinde” in the “Template” field and “downloads”,
“isohunt” or “piratebay” in the “Macro” field, depending on the
search box you want to display. Click Save.Note you can insert more than one search box in your site repeating the steps
2-4 and entering a different key-name in “Macro”.
Package: lalsuite
LALSuite is the LIGO Scientific Collaboration Algorithm Library for
gravitational-wave analysis. Its primary purpose is searching for and
characterizing astrophysical signals in gravitational-wave time series data,
particularly data from ground-based detectors such asLIGOandVirgo.LALSuite consists of a set ofconfigure-make-installstyle software
packages organized by problem domain or source classification. This Python
package provides a standalone, dependency-free binary distribution of the
libraries and Python modules in LALSuite for Linux and macOS.Installing LALSuite from the Python Package Index requires pip >= 19.3.To install, simply run:$ pip install lalsuiteOptional dependencies, which can be installed aspip install lalsuite[option]:lalinference(pulls ingwdatafindandgwpy)lalpulsar(pulls insolar_system_ephemeridesto provide ephemeris files which, until LALSuite 7.15, were still included in
the main package)test(pulls inpytest)
Package: lama-cleaner
Lama CleanerA free and open-source inpainting tool powered by SOTA AI model.https://user-images.githubusercontent.com/3998421/196976498-ba1ad3ab-fa18-4c55-965f-5c6683141375.mp4FeaturesCompletely free and open-source, fully self-hosted, support CPU & GPU & M1/2Windows 1-Click InstallerNative macOS appMultiple SOTA AImodelsErase model: LaMa/LDM/ZITS/MAT/FcF/MangaErase and Replace model: Stable Diffusion/Paint by ExamplePluginsfor post-processing:RemoveBG: Remove images backgroundRealESRGAN: Super ResolutionGFPGAN: Face RestorationRestoreFormer: Face RestorationSegment Anything: Accurate and fast interactive object segmentationFileManager: Browse your pictures conveniently and save them directly to the output directory.More features atlama-cleaner-docsQuick StartLama Cleaner make it easy to use SOTA AI model in just two commands:# In order to use the GPU, install cuda version of pytorch first.# pip install torch==1.13.1+cu117 torchvision==0.14.1 --extra-index-url https://download.pytorch.org/whl/cu117pipinstalllama-cleaner
lama-cleaner--model=lama--device=cpu--port=8080That's it, Lama Cleaner is now running athttp://localhost:8080See all command line arguments atlama-cleaner-docsDevelopmentOnly needed if you plan to modify the frontend and recompile yourself.FrontendFrontend code are modified fromcleanup.pictures, You can experience their
great online serviceshere.Install dependencies:cd lama_cleaner/app/ && pnpm installStart development server:pnpm startBuild:pnpm build
Package: lama-cleaner-custom
Lama CleanerA free and open-source inpainting tool powered by SOTA AI model.https://user-images.githubusercontent.com/3998421/196976498-ba1ad3ab-fa18-4c55-965f-5c6683141375.mp4Sponsor❤️ Your logoFeaturesCompletely free and open-source, fully self-hosted, support CPU & GPU & M1/2Windows 1-Click InstallerMultiple SOTA AImodelsErase model: LaMa/LDM/ZITS/MAT/FcF/MangaErase and Replace model: Stable Diffusion/Paint by ExamplePluginsfor post-processing:RemoveBG: Remove images backgroundRealESRGAN: Super ResolutionGFPGAN: Face RestorationRestoreFormer: Face RestorationMore features atlama-cleaner-docsQuick StartLama Cleaner make it easy to use SOTA AI model in just two commands:# In order to use the GPU, install cuda version of pytorch first.# pip install torch==1.13.1+cu117 torchvision==0.14.1 --extra-index-url https://download.pytorch.org/whl/cu117pipinstalllama-cleaner
lama-cleaner--model=lama--device=cpu--port=8080That's it, Lama Cleaner is now running athttp://localhost:8080See all command line arguments atlama-cleaner-docsDevelopmentOnly needed if you plan to modify the frontend and recompile yourself.FrontendFrontend code are modified fromcleanup.pictures, You can experience their
great online serviceshere.Install dependencies:cd lama_cleaner/app/ && pnpm installStart development server:pnpm startBuild:pnpm build
Package: lamarkdown
LamarkdownLamarkdown is a command-line document preparation system based onPython-Markdown. It attempts to address similar use cases to LaTeX, but using the Markdown and HTML formats. It isnotdirectly intended to build static websites, though its extensions can be reused inMkDocs(or in other applications based on Python-Markdown).Take theLamarkdown tourto get a first impression.Requirements and InstallationLamarkdown depends on Python 3.8+. To install via pip:$pipinstalllamarkdownBasic UsageTo compilemydocument.mdintomydocument.html, run:$lamdmydocument.mdTo enable the live-update mode, use-l/--live:$lamd-lmydocument.mdThis will launch a local web-server and a web-browser, and will keepmydocument.htmlin sync with any changes made tomydocument.md, until you press Ctrl+C in the terminal.Full DocumentationSee the full documentation atlamarkdown.github.io.
Package: lamart-sendbox-sdk
SDK for Mail.ru Sendbox rest apiUsagefromsendbox_sdk.apiimportSendBoxApisendbox_api=SendBoxApi("sendbox_account_id","sendbox_account_secret")sendbox_api.send_templated_email(context={'template_parameter1':'test','template_parameter2':'test',},from_email='test@example.come',from_name="Example",to_email='user@example.com',to_name="Username",subject="Subject")InstallationRequirementsrequestsCompatibilityLicenceMITAuthorssendbox_sdkwas written byYasha Mikhoparkin.
Package: lamatok
Lamatok client, for Python 3Installationpip install lamatokUsageCreate a tokenhttps://lamatok.com/tokensand copy "Access key"fromlamatokimportClientcl=Client(token="<ACCESS_KEY>")fromlamatokimportAsyncClientcl=AsyncClient(token="<ACCESS_KEY>")Run testsLAMATOK_TOKEN=<token> pytest -v tests.py
Package: lamb
Lamb 🐑: Concise Function Expression in PythonThis module introduces a new way to express small functions in a compact and intutive way using a single object calledlamb. Any expression in which alambappears turns into a function of whichlambis a parameter. Checkdemo.pyto see a demonstration:fromlambimport*# Primary purpose: Creating small anonymous functionsres=filter(lamb%5<3,range(30))# Arbitrary arithmetic and boolean operators are allowed:f=(lamb**2%6)-28!=5/4f_l=lambdax:(x**2%6)-28!=5/4f(2)==f_l(2)# The two expressions are equivalent# Empty function calls, index and attribute access are possible as wellg=lamb().x[2]-3==None# Lambs can be chained with other functions using the righshift operatorh=g>>f>>lamb+2# make sure the first function is a lamb# For multi-variable lambs, different lamb names improve clarityfromlamb.vsimport*# Imports a, b, c, ..., zfromlamb.l_vs_import*# Import l_a_, l_b_, .. arbitrary pre- and postfixes are possibleg=(l_a_-b)*c# g is now a function of three arguments, or rather: functions returning functions,# with one argument each (shoutout to Haskell)g(1)(2)(3)==g(1,2)(3)==g(1,2,3)# Arguments replace lambs left-to-right. The following will output -3:g(1,2,3)# Note that `a_ is b_` and `a_ is lamb`; they differ only in their identifier.# In other words, the following are equivalent:g2=(lamb-lamb)*lambg(1,2,3)==g2(1,2,3)# Lambs can be nested. Parents inherit un-evaluated lambs from their children.# For clarity, lambs can be added as placeholder for unevaluated args:h=g(1,2)+g(3)h2=g(1,2,a)+g(3,a,b)h(1,2,3)==h2(1,2,3)# In a select few cases, this will work, but is discouraged. Use g = lamb >> f instead.f=lambdax:x+2==5g=f(lamb)f(2)==g(2)Installationlambis installable from PyPI:python -m pip install lamb
Package: lambada-launcher
LambadaLambada allows to launch and supervise multiple commands.Launch withpython3-mlambadaorlambadaSeelambada.tomlfor an example file.[analog]cmd="xclock"[digital]cmd="xclock -digital"Commands are described by their name and acmdstring field. Following options are availables :shellif set totrueinterpret thecmdinbash(allows to launch multiple commands and use bash features
such as|or>)persistif set totrue, task is not terminated when lambada exits normally.detachif set totrue, task is detached from lambada and does not receive signal (SIGINTor Ctrl+C) send to
lambada.acquireif set totrue, monitor pre-existing task. Might be completed bybasedOn. If no task is found, launch
a new one.basedOnsupport two way to retrieve pre-existing task{method="grepCmd"}will try to find a process with exact samecmdas defined{method="listenPort", port=1234}will try to find a process listeing to the givenport.
Package: lambchop
lambchopA sidekick that makes your AWS Lambda asyncOverviewlambchopis an Python package that gives regular AWS Lambda asyncronous functionality by allow them to run background processes. This works by utilizing AWS Lambdaextensionswhich runs in a different process than the main lambda function code.Installationpypi:pip install lambchopgithub:pip install git+ssh://git@github.com/dave-lanigan/lambchop.gitpip install git+https://git@github.com/dave-lanigan/lambchop.git📝 Sudo privileges may be required because the lambda extension resides in the/opt/extensions/directoryUsageimport time
from lambchop import SideKick

def long_running_process(x, y):
    print("Starting process 1.")
    time.sleep(x + y)
    print("Completed.")


def long_running_process2(x, y):
    print("Starting process 2.")
    time.sleep(x + y)
    print("Completed.")


def main():
    sk = SideKick()
    sk.add_task(long_running_process, x=5, y=3)
    sk.add_task(long_running_process2, x=5, y=3)
    sk.process()

if __name__ == "__main__":
    main()
Package: lambda2color
![license](https://img.shields.io/badge/license-MIT-blue) [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/laurentperrinet/lambda2color/main)
[![PyPI version](https://badge.fury.io/py/lambda2color.svg)](https://badge.fury.io/py/lambda2color)# lambda2color: convert a given light wavelength into the corresponding RGB colorThis is a simple library to transform a given light wavelength into the corresponding RGB color.It is based on the different sensitivities to a novel color space called the [CIE 193 “ XYZ” color space](https://en.wikipedia.org/wiki/CIE_1931_color_space) and defined by the CIE colour matching function for 380 - 780 nm in 5 nm intervals :![CIE colour matching function](cmf.png)This allows to simply compute for instance the color of different monochromatic lights:![Rainbow](spectrum.png)For more advanced uses, see for instance this blog post computing [the color of the sky](https://laurentperrinet.github.io/sciblog/posts/2020-07-04-colors-of-the-sky.html).
Package: lambda-agent-utils
Lambda Utilities is a Python package that provides utility functions for handling input and output in AWS Lambda functions triggered by various sources, including API Gateway, AWS Service Kafka, and CLI.FeaturesEasily extract and format input parameters based on the trigger source.Send output data back to the appropriate source with proper formatting.Supports AWS Lambda functions for various use cases.UsageTo use Lambda Utilities in your AWS Lambda functions, follow these steps:Import theinput_handlerandoutput_handlermodules.Use these modules to streamline input and output handling.LicenseThis project is licensed under the MIT License.
Package: lambdabase
LambdaBaseA library to support development of enterprise Serverless applications.Serverless computing allows you to build and run applications without expending time and
effort managing a server. Code is executed and billed only when called. Whilst this model
provides many advantages such as horizontal scalability and reduced operational costs
it creates it's own set of drawbacks such as debugging, testing and packaging.There are numerous articles detailing the advantages and disadvantages of serverless
architectures. It's worth considering all the salient points before starting down the
serverless path however, in general, the zero configuration horizontal scalability
and cost efficiencies are the most significant driving factors. The architecture
described here helps to mitigate the disadvantages whilst magnifying the advantages.As with any architecture there is no one size fits all solution, however, I've seen the
following pattern implemented successfully in both Java and Python across multiple domains.
I believe it provides a reasonable amount of flexibility whilst being sufficiently structured
to help developers rapidly implement clean code. One of the guiding principles of this
pattern is to overcome one of the most significant issues with Serverless - the difficulty
of debugging and testing Serverless ready code in a local environment.The key design points and the basis for this architecture are as follows:Lambdas are grouped into functional areas. Each group contains multiple lambdas with
different handlers for each function. This is to allow related lambdas to share common
ode more easily and to simplify packaging and application structure.It should always be possible to execute and debug the lambda code locally.The configuration for each environment is packaged with each lambda. Which
configuration file to use is specified by an environment variable which is specified
at deployment time.The code to package and deploy each of the lambdas lives with the runtime codeOne click deployment to new environments should be trivial, and the concept of
infrastructure as code should be maintained at all times.Dependency injection is used to allow alternative services to be injected into lambdas
depending on where they are running.The proposed architecture is designed to fulfill these high level goals whilst maintaining
a flexibility which should allow future extension and resilience to changing project requirements.Push to PyPi:python setup.py bdist_wheel
python -m twine upload lambdabase-0.x-py2-none-any.whl
Package: lambdabuild
LambdaBuildThis is a single command line executable meant to be triggerred from within
make or make like script, which automates creation of AWS lambda python artifacts,
and AWS lambda layers.Features:build inside docker emulating lambda environment, with target python runtimeprecompile .pyc files, for faster cold startssupport build-only-if-changedresult zip file hash will remain identical between builds (important when
infrastructure as code decides wether to update lambda / layer, since
previous build was not on same machine)
Package: lambda-calculus
lambda_calculusThelambda_calculuspackage contains classes which implement basic operations of the lambda calculus.To use it, simply import the classesVariable,AbstractionandApplicationfrom this package
and nest them to create more complex lambda terms.You can also use thevisitorssubpackage to define your own operations on terms or
use predefined ones from thetermssubpackage.More information is available onRead the Docs.NoticeThis package is intended to be used for educational purposes and is not optimized for speed.Furthermore, it expects all terms to be finite, which means the absence of cycles.RecursionErrormay be raised if the visitors get passed an infinite term or the evaluation is too complex.RequirementsPython >= 3.10 is required to use this package.Installationpython3-mpipinstalllambda-calculusExamples(λy.(λx.(λy. + x y)) y 3) 4Nestingfromlambda_calculusimportVariable,Abstraction,Applicationterm=Application(Variable("+"),Variable("x"))term=Application(term,Variable("y"))term=Abstraction("y",term)term=Abstraction("x",term)term=Application(term,Variable("y"))term=Application(term,Variable("3"))term=Abstraction("y",term)term=Application(term,Variable("4"))Utility Methodsfromlambda_calculusimportVariable,Abstraction,Applicationx=Variable.with_valid_name("x")y=Variable.with_valid_name("y")term=Application.with_arguments(Variable.with_valid_name("+"),(x,y))term=Abstraction.curried(("x","y"),term)term=Application.with_arguments(term,(y,Variable.with_valid_name("3")))term=Abstraction("y",term)term=Application(term,Variable.with_valid_name("4"))Method Chainingfromlambda_calculusimportVariable,Abstraction,Applicationx=Variable.with_valid_name("x")y=Variable.with_valid_name("y")term=Variable("+")\.apply_to(x,y)\.abstract("x","y")\.apply_to(y,Variable("3"))\.abstract("y")\.apply_to(Variable("4"))Evaluationfromlambda_calculusimportVariable,Applicationfromlambda_calculus.visitors.normalisationimportBetaNormalisingVisitorassertBetaNormalisingVisitor().skip_intermediate(term)==Application.with_arguments(Variable("+"),(Variable("4"),Variable("3")))
Package: lambda-cli
lambda-cliCLI for managingLambda Labsinstances.Installationpipinstalllambda-cliYou may also install the package from source:gitclonehttps://github.com/gmittal/lambda-clicdlambda-cli
pipinstall.UsageAuthenticate with your email and password:lambdaauthCreate instances:$lambdaup--instance_type=gpu.8x.v100List existing instances:$lambdals
IDIPINSTANCE_TYPESTATE
23d0a8af2e414762ab8a10d3841d9574104.171.203.194gpu.8x.v100BOOTINGTerminate instances:$lambdarm23d0a8af2e414762ab8a10d3841d9574LicenseMIT
Package: lambdacloud
lambdacloudAn unofficial python client for Lambda Lab's cloud computing platform.Installationpip install lambdacloudUsageAuthenticatefromlambdacloudimportloginlogin(token="<your token>")Create an InstanceSee "list-available-instance-types" for a list of available instance types. Also, see "list-available-ssh-keys" for a list of available ssh keys.fromlambdacloudimportcreate_instanceinstance_id=create_instance("gpu_1x_a10",ssh_key_names="my-ssh-key")print(instance_id)"""["<instance id>"]"""Delete an Instancefromlambdacloudimportdelete_instancedelete_instance("<instance id>")List Instancesfromlambdacloudimportlist_instancesinstances=list_instances()print(instances)List Available Instance Typesfromlambdacloudimportlist_instance_typesinstance_types=list_instance_types()forinstance_typeininstance_types:print(instance_type)"""InstanceType(name=gpu_8x_a100_80gb_sxm4, price_cents_per_hour=1200, description=8x A100 (80 GB SXM4))InstanceType(name=gpu_1x_a10, price_cents_per_hour=60, description=1x A10 (24 GB PCIe))InstanceType(name=gpu_1x_a100_sxm4, price_cents_per_hour=110, description=1x A100 (40 GB SXM4))InstanceType(name=gpu_8x_a100, price_cents_per_hour=880, description=8x A100 (40 GB SXM4))InstanceType(name=gpu_8x_v100, price_cents_per_hour=440, description=8x Tesla V100 (16 GB))"""# To show all instance types, even if they are not available to createinstance_types=list_instance_types(show_all=True)List Available SSH Keysfromlambdacloudimportlist_ssh_keysssh_keys=list_ssh_keys()forssh_keyinssh_keys:print(ssh_key)"""SshKey(name=my-ssh-key)"""Add an SSH Keyfromlambdacloudimportadd_ssh_keyadd_ssh_key("my-ssh-key","<public key>")Add an SSH Key from a Filefromlambdacloudimportadd_ssh_key_from_fileadd_ssh_key_from_file("my-ssh-key","<path to public key file>")CreditsThis package is heavily inspired byhuggingface_hub
Package: lambda-config
lambda-configmakes it easy to load lambda configuration stored on SSM parameter store.Installationlambda-configis listed onPyPIand can be installed with pip:pipinstalllambda-configExampleAdd the config as either json/yaml/ini to a path in the SSM parameter storeAdd the following env variables to the lambdaSSM_PARAMETER_PATH- the path to parameterSSM_CONFIG_TYPE-json/yaml/iniImport and use the configfromlambda_configimportconfig# now you can use the config. config is a dictionaryLicenseThis project is licensed under theMIT License.MIT License

Copyright (c) 2019 Niranjan Rajendran

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: lambda-controller
lambda-controller===============Command line utility for AWS Lambda.Installation~~~~~~~~~~~~The latest release of lambda-controller can be installed via pip:::pip install lambda-controllerAn alternative install method would be manually installing it leveraging``setup.py``:::git clone https://github.com/cloudfish7/lambda-controllercd lambda-controllerpython setup.py installCommand Line Usage~~~~~~~~~~~~~~~~~~See the Lambda Function List.. code:: shelllambda-controller --listSee the Lambda Function Info.. code:: shelllambda-controller --detailTo invoke Lambda Function.. code:: shelllambda-controller --invoke FunctionName