Saravanan666/pypi-org huggingface dataset:
Package: levitydash
LevityDashA lightweight, desktop native, multisource dashboard for macOS, Windows and LinuxLevityDash aims to be a lightweight, desktop native, multisource dashboard without a required web frontend. The current version only supports PySide2/Qt. However, a key goal of this project is to support multiple frontends and
platforms, including embedded.Note: This project is very much in the proof of concept stage – it functions, but it is far from the goal of a lightweight dashboard.Current FeaturesBackendPlugin system for adding new sourcesScheduling API pullsData/key maps for automatically parsing ingested dataUnit library for automatic localization/conversionConditional value updates. i.e. if wind speed is zero do not log the wind directionData SourcesREST API PullSockets (UDP, websocket, socket.io)BLE AdvertisementsBuiltin PluginsOpen-Meteo[REST]WeatherFlow Tempest[REST, UDP, Websocket(incomplete)]Govee BLE Thermometers/Hygrometers [GVH5102]FrontendDrag and drop dashboard design (This can be a little funky at times)YAML based dashboard specifications with support for both absolute and relative size/positioningModule groupingEditable Margins for text modulesResizable graph figuresCustom, value mapped, gradients for figure itemsText filters (i.e. lower, title, upper, digit to ordinal, etc.)Current ModulesRealtime single line text with support for showing units and titles and mapping glyphs/emojis to valuesTimeseries GraphCustomizable ClockMoon PhaseSubmodule Group for organizing modulesPlanned ModulesGauges [nearly complete]Weather RadarMultiline TextRSS FeedsCalendarMini GraphsMore plot types
Package: levmar
A Python binding to the levmar library. Note that this is a fork ofhttps://github.com/tkanmae/levmar.DescriptionThe levmar is GPL’ed ANSI C implementation of theLevenberg-Marquardt
(LM) optimization algorithm.
The LM algorithm provides a numerical solution to the problem of minimizing
a function over a parameter space
of a function.  The levmar library provides implementation of both
unconstrained and constrained LM algorithms (box, linear equation, and
linear inequality constraints).InstallationSimplest way to install levmar and its dependencies is to use theconda package manager:$ conda install -c bjodah levmar pytest
$ python -m pytest --pyargs levmar  # runs the test-suitealternatively you may also usepip:$ python -m pip install --user --upgrade pytest levmar
$ python -m pytest --pyargs levmaryou can skip the--userflag if you have got root permissions.DocumentationSee docstrings and demo scripts contained in the directory./examples.  Documentation of the levmar library can be found athttp://www.ics.forth.gr/~lourakis/levmar/. Auto-generated API documentation
for the latest stable release of this wrapper is found here:https://bjodah.github.io/levmar/latest(and the development version for the current master branch of this wrapper
is found here:http://hera.physchem.kth.se/~levmar/branches/master/html).AuthorsTakeshi Kanmae <tkanmae@gmail.com>.
For all authors seeAUTHORS.LicenseThe MIT license applies to all the files except those in./levmar-2.6.  All of the software in./levmar-2.6and only the
software therein is copyrighted by Manolis Lourakis and is licensed
under the terms and conditions of the GNU General Public License (GPL).
See the fileLICENSE.txt.Resourceslevmar:http://www.ics.forth.gr/~lourakis/levmar/Python:http://www.python.org/NumPy:http://www.scipy.org/nose:http://somethingaboutorange.com/mrl/projects/noseCython:http://www.cython.org/
Package: levmarq-torch
levmarq-torchA basic PyTorch implementation of the Levenberg-Marquardt algorithm. This solves minimization problems of the form$$\mathbf{x}^* = \mathrm{argmin}_{\mathbf{x}} |\mathbf{y} - \mathbf{\hat{y}}(\mathbf{x})|^2 , .$$The implementation is batched over the parameters $\mathbf{x}$ and datapoints $\mathbf{y}$.Based on implementation 1 fromGavin 2022and some help fromConnor Stone.InstallationRunninggit clone git@github.com:adam-coogan/levmarq-torch.git
cd levmarq-torch
pip install .will install thelevmarq_torchpackage.
Package: levv
levv - Log File Event ViewerCommand line based graphical log file viewer.Table of contentsInstallExamplesKeyboardCommand LineReferencesInstall$ pip3 install levvExampleskernel messageslevv -i /dev/kmsg -I kmsgsyslog messageslevv -i /var/log/syslogApache web logslevv -i /var/log/apache2/access.log -I wwwnginx web logslevv -i /var/log/nginx/access.log -I wwwView data from stdin / pipeecho "Hello World!" | levv -i -tail -f /path/to/some/file.log | levv -i -KeyboardLEFT = Scroll back in timeRIGHT = Scroll forward in timeUP = Zoom inDown = Zoom outs = Scroll automaticallyl = Change number of lines per recordq / esc = QuitCommand Lineusage: levv [-h] [--inputfile INPUTFILE] [--inputformat INPUTFORMAT]
            [--inputbreak INPUTBREAK] [--inputfilter INPUTFILTER]
            [--outputfile OUTPUTFILE] [--outputformat OUTPUTFORMAT]
            [--timerange TIMERANGE] [--time TIME] [--refresh REFRESH]
            [--scroll SCROLL] [--lines LINES] [--maxmsgbuf MAXMSGBUF]
            [--maxfileread MAXFILEREAD] [--debug]

Event monitor.

optional arguments:
  -h, --help            show this help message and exit
  --inputfile INPUTFILE, -i INPUTFILE
                        Log file to parse
  --inputformat INPUTFORMAT, -I INPUTFORMAT
                        Input data format
  --inputbreak INPUTBREAK, -b INPUTBREAK
                        Line break
  --inputfilter INPUTFILTER, -f INPUTFILTER
                        Regex filter expression for input data
  --outputfile OUTPUTFILE, -o OUTPUTFILE
                        Append logs to output file
  --outputformat OUTPUTFORMAT, -O OUTPUTFORMAT
                        Output data format
  --timerange TIMERANGE, -r TIMERANGE
                        Time range
  --time TIME, -t TIME  Time start
  --refresh REFRESH, -R REFRESH
                        Data refresh interval in seconds, 0 for no refresh
  --scroll SCROLL, -s SCROLL
                        1-100, percentage of screen for auto scroll position,
                        0 = Do not auto scroll
  --lines LINES, -l LINES
                        Number of lines per timeline item, can be 1, 2, or 3
  --maxmsgbuf MAXMSGBUF, -m MAXMSGBUF
                        Maxium number of messages to queue
  --maxfileread MAXFILEREAD, -M MAXFILEREAD
                        Maxium number of bytes to read from a file, 0 for all
  --debug, -D           Show debug informationReferencesPythonhttps://www.python.org/piphttps://pip.pypa.io/en/stable/
Package: lewd-dl
lewd-dlCommand-line tool to download videos from lewd websitesINSTALLATIONTo install lewd-dl via pip, run:python -m pip install lewd-dlTo install lewd-dl from source, run:git clone https://github.com/b3yc0d3/lewd-dl.git
cd lewd-dl
make installDEVELOPMENTIf you want to contribute to this project, please send a pull-request to thedevbranch.To setup lewd-dl for development, run:git clone https://github.com/b3yc0d3/lewd-dl.git
cd lewd-dlTo build it run:make buildAfter the first build, you need to install it localy. This step only needs to be done once OR when you changed something in thesetup.py. Simply run:make installWEBSITE SUPPORTWebsitesStatusVersionxvideos.comFull Support0.1.0xhamster.vomFull Support0.1.0xnxx.vomFull Support0.1.0pornhub.comFull Support0.1.0youporn.comPlaned?.?.?xhamster.desiPlaned?.?.?hanimetv.tvPlaned?.?.?USAGEusage: lewd-dl [-h] [--user-agent UA] [-r RES] [--rate-limit SEC] [-f FORMAT] [-o OUTPUT] [--cache-dir DIR] [-R]
               [--dump-user-agent]
               [url]

positional arguments:
  url                Video urls to download

options:
  -h, --help         show this help message and exit
  --user-agent UA    Set user agent
  -r RES             Select resolution to download (By deafult "best" is chossen)
  --rate-limit SEC   Time to wait between download requests (default 0.5s)
  -f FORMAT          Select format to download (default mp4)
  -o OUTPUT          Output filename
  --cache-dir DIR    Set custom cache folder
  -R                 Prints available resolutions and exits
  --dump-user-agent  Prints current user-agent then exits
Package: lewdsfunpy
LewdsFunPyFor Use with the Lewds image API!Installationpip3installlewdsfunpyAPI Keys:# .env
LEWDS_API_KEY=[REPLACE_WITH_YOUR_OWN_KEY]Example Usage:fromlewdsfunpyimportLewdsAPIdeftest():""" Tests the Lewds API Endpoints """resultz=LewdsAPI.nsfw("ass")print("{name}".format(name=resultz))Join theDiscord Server
Package: lewis
Lewis - Let’s write intricate simulators.Lewis is a Python framework for simulating hardware devices. It is
compatible with Python 3.6 or higher.Lewis can be installed via pip or ran from source. See relevant usage sections atReadTheDocsfor more details.Resources:GitHub–ReadTheDocs–PyPILewis was previously named “Plankton” but, due to a
package with the same name on PyPI, we decided to rename the project.Lewis is licensed under GPL v3 or later.Purpose and Use CasesLewis is being developed in the context of instrument control at theESS, but it is general enough
to be used in many other contexts that require detailed, stateful
software simulations of hardware devices.We consider a detailed device simulation to be one that can communicate
using the same protocol as the real device, and that can very closely
approximate real device behaviour in terms of what is seen through this
protocol. This includes gradual processes, side-effects and error
conditions.The purpose of Lewis is to provide a common framework to facilitate
the development of such simulators. The framework provides a common set
of tools, including communication protocol services, which helps minimize code
replication and allows the developer of a simulated device to focus on
capturing device behaviour.Potential use cases for detailed device simulators include:Replacing the physical device when developing and testing software
that interfaces with the deviceTesting failure conditions without risking damage to the physical
deviceAutomated system and unit tests of software that communicates with
the devicePerform “dry runs” against test scripts that are to be run on the
real deviceUsing a simulation for the above has the added benefit that, unlike most
real devices, a simulation may be sped up / fast-forwarded past any
lengthy delays or processes that occur in the device.FeaturesBrief TerminologyDevices andInterfaces are two independent concepts in
Lewis. TheDeviceis model for the device behaviour and internal
memory. ADevicecan be represented using aStateMachine, but it
does not have to be. ADevicedoes not include anything specific to
the communication protocol with theDevice. AnInterfaceprovides bindings from a protocolAdapterto aDevice.
CommonAdapters, , such as TCP stream, Modbus and EPICS, are provided
by Lewis. TheDeviceandInterfaceare instantiated as part of aSimulationthat provides a cycle “heart beat” and manages other
environmental aspects and services.What Can You Do With Lewis?Create newDevices to closely imitate the internal behaviour
and memory of somethingOptionally make aDevicework as aStateMachineviaStateMachineDeviceto give rich behavioursCreate one or moreInterfaces over yourDeviceto expose it
as an EPICS IOC, a TCP listener, or on any other bespoke protocol you
likeAccess and control theDevicewhile it is running via a control serverAccess and control theSimulationwhile it is running via a control serverControl server can be accessed via command-line utility, Python bindings, or
JSON RPC.Additional DocumentationDocumentation can be found atReadTheDocs.
Package: lex2sent
Lex2Sent - A bagging approach to unsupervised Sentiment AnalysisLex2Sent is a text classification/clustering model that can be used with minimal a-priori-information to classify texts into two classes. While theoriginal paperused it for sentiment analysis on english documents, it is not limited to that purpose, but can be used for any arbitrary type of classification and language as long as there are lexica that can be used as an information-basis.Getting StartedYou may install this package using either pypipip install lex2sentor GitHubpip install git+https://github.com/K-RLange/Lex2Sent.gitThe following is an example of using the Opinion Lexicon to classify an iMDb movie review data set. You may have to usenltk.download()to download the opinion_lexicon first.
First we configure our data setfrom datasets import load_dataset
from nltk.corpus import opinion_lexicon
data = load_dataset('imdb')
ratings, reviews = [], []
for stars, text in zip(data["train"]["label"], data["train"]["text"]):
    if text:
        if stars == 0:
            ratings.append("negative")
        else:
            ratings.append("positive")
        reviews.append(text)And now we can start applying Lex2Sentfrom lex2sent.textClass import *
lexicon = ClusterLexicon([opinion_lexicon.positive(), opinion_lexicon.negative()])
rated_texts = RatedTexts(reviews, lexicon, ratings)

#Basic "counting" method of classification:
count_res = rated_texts.lexicon_classification_eval(label_list=["positive", "negative"])
l2s_res = rated_texts.lbte(label_list=["positive", "negative"], workers=4)
print("Counting accuracy: {}%; Lex2Sent accuracy: {}%".format(count_res * 100, l2s_res*100))yielding the result "Counting accuracy: 73.772%; Lex2Sent accuracy: 78.172%".ReferencePlease refer to"Lex2Sent - A bagging approach to unsupervised Sentiment Analysis"when using this package. When you use this package in a publication, please cite it as@misc{lex2sent,
  title = {{Lex2Sent}: {A} bagging approach to unsupervised sentiment analysis},
	shorttitle = {{Lex2Sent}},
	publisher = {arXiv},
	author = {Lange, Kai-Robin and Rieger, Jonas and Jentsch, Carsten},
	month = sep,
	year = {2022},
	note = {arXiv:2209.13023 [cs]},
	keywords = {Computer Science - Computation and Language},
}Future Features-Calling from the console-FastText and SentenceBERT as alternatives to Doc2Vec-Options to classify into more than two clusters
Package: lexapi
Lex APIpip install lexapiLexis a personal ads service for queer people.
It's a brilliant service, and if you fall under the target groups you
should definitely go check it out.This is a Python 3 API created from the work I did between early-mid
2020, gathering the web request data the app sent from my phone. Because
of this work I was able to alert the Lex team one possible privacy
vulnerability from the service, which has since been removed.This work was performed with the help of Android-86x, andmitmproxy.Lex relies on Google's Identity toolkit and Firebase to handle
authentication, and relies on Chatkit to handle messaging, through a
websockets interface.Currently this API supports probably about half of the available
functions, including feed-viewing and user profile updating. SeeLex
API/Currently missingThe functions are all named after their respective calls, so you can useLex-apifor examples of the expected responses.Docmentation of the API calls themselves, along with IdentityToolkit
authentication, and information about X-Goog-Spatula are contained inlex-api, the code itself should be clean enough to
extend, but please open an issue if there's anything re: code style,
etc. that I've messed up. Literally any improvements or iterations
would be nice :)This readme wouldn't be complete without ahugethanks to the Lex
team for making such a cool and unique service :)Example# Importing:

    from lexapi import LexAPI
    lex = LexAPI()

# Logging in:

    # Pass the user's phone number
    lex.send_verification_code(phone_number)
    # User gets a message with the auth code, so now we can pass it
    lex.verify_phone_number(verification_code)
    # We are now logged in to the service, but we need the user's feed
    # preferences to get the feed, so:
    lex.get_user()

# Refreshing the token:

    lex.refresh_token()

# Getting the feed:

    lex.get_feed()

# or alternately:

    filters = {
        'max_age': 32,
        'filters': 'foo, bar'
    }
    lex.get_feed(filters)Currently missing {#currently-missing id="0c2915c7-e3d5-4a80-95af-0c78880dd823"}Currently missing functionality is:Username / Instagram logging in, and logging out (It's on my TODO)Because of the limitations of mitmproxy, and the updates to the
service, posting new personals is not supported (It's on my TODO
list to jury-rig something with HTTP/2 support so we can support
adding new posts).Because of the method they use with Chatkit, viewing anything but
the most and posting messages cannot, and will not be supported by
this API, as it requires a private encryption key stored in the
application.
Package: lex-bot-deploy
lex-bot-deployDeployment and export Amazon Lex Schema bots.
Makes it easy to maintain bots in source, share and use for CI/CD processes:lex-bot-deploy --example BookTripAlso supports getting the JSON schema easily:lex-bot-get-schema --lex-bot-name BookTripAnd you can specify which schema you would like to deploy obviously:lex-bot-deploy -s BookTrip_Export.jsonFree software: MIT licenseDocumentation:https://lex-bot-deploy.readthedocs.io.FeaturesLet me know :-)make creation of permissions optionalallow mapping of Lambda endpoints or allow options to map aliases to Lambda function (tbd)CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.8 (2018-11-12)enable Python 2.70.1.7 (2018-11-12)Adding examples to deploy package0.1.6 (2018-11-12)Adding examples to deploy package0.1.5 (2018-11-12)add region endpoint exception check0.1.4 (2018-11-12)fix lex-bot-get-schema not exposed as script0.1.3 (2018-11-11)added examples as option for deployment0.1.2 (2018-11-10)added creation of Lambda permissions for Lex bot0.1.1 (2018-11-09)added lex-bot-get-schema script and function0.1.0 (2018-11-08)First release on PyPI.
Package: lexc2dix
# lexc2dixA software that parses over the existing lttoolbox format and generates the corresponding monolingual dictionary in lttoolbox format. The package is modular and is user-friendly with proper help message and usage instructions. This was done as a part of coding challenge for the project `Extend lttoolbox to have the power of HFST`.INSTALLATION------------If you are a user and are simply looking to install the package, just type the command given below in your terminal window.```$ pip3 install lexc2dix```To get proper usage instructions for the package, type the command given below.```$ lexc2dix -e```GETTING STARTED---------------These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.### CLONE THE REPOSITORY```$ git clone https://github.com/Techievena/lexc2dix.git$ cd lexc2dix```### INSTALL PREREQUISITES```$ pip3 install -r requirements.txt$ pip3 install -r test-requirements.txt```### INSTALL THE PACKAGE```$ python3 setup.py install```### USAGE```$ lexc2dix --helpusage: lexc2dix [-h] [-e] [-v] [filename]lexc2dixpositional arguments:filenameoptional arguments:-h, --help     show this help message and exit-e-v, --version$ lexc2dix tests/test_files/apertium-kaz.kaz.lexc```EXTERNAL LIBRARIES USED-----------------------* regex 2018.02.21 (Python 3)CAPABILITIES AND POSSIBILITIES------------------------------The lexc2dix module is expected to function as follows:- [x] Parses over the lexc files.- [x] Stores them in form of python dictionaries.- [x] Generates the monolingual dictionary files.CONTRIBUTION------------The work flow is the same as that of any other repository.1.Fork / clone the repository.2.Create a new branch , say `my-changes` and make your changes in this branch.3.Commit your changes and send a Pull request (PR) to this repository.Active contributors would be rewarded with the tag of "Collabrators".Bug fixes , Issues , Issue solutions , Optimizations & Enhancements are always welcome.LICENSE-------The GNU GENERAL PUBLIC LICENSE - [Abinash Senapati](http://github.com/Techievena) - All Rights Reserved.ACKNOWLEDGEMENTS----------------I would like to thank mentors at [Apertium](https://github.com/Apertium) for helping me with the development and maintenance of this package.
Package: lexedata
lexedataLexedata is an open source Python package that includes a collection of command line tools to edit comparative lexical data in the CLDF format (https://doi.org/10.1038/sdata.2018.205), which adds an ontology of terms from comparative linguistics (https://cldf.clld.org/v1.0/terms.html) to the W3C “CSV for the Web” (csvw,https://w3c.github.io/csvw/) standard. The package includes tools to run batch-editing operations as well as tools to convert CLDF to and from other data formats in use in computational historical linguistics.The documentation for Lexedata can be found onReadTheDocs.IO.The package is available fromPyPI. If you have a recent Python installation, you can easily install it usingpip install lexedataMore detailed installation instructions can be foundin the documentation.Lexedata was developed from the practical experience of editing several specific different lexical data sets, but generalizes beyond the specific datasets. The aim is to be helpful for editors of other lexical datasets, and as such we consider lacking documentation and unexpected, unexplained behaviour a bug; feel free toraise an issue on Githubif you encounter any.
Package: lex-game
LEX --- Learning EX-a-pawnA game written by Mattia Monga for a 'Coding for lawyers' course. Copyright
2020 - Free to distribute, use, and modify according to the terms ofGPLv3.The code is simplistic but this version uses an OOP style; see branchmasterfor an even simpler
approach.Installationpip install lex_gamelex_game -hgives help on command line arguments.Rules of the gamePawns move and capture as in chess, but there are neither two-step moves nor en-passant captures.
Players win by reaching the last row or by blocking the opponent.
Moves are given by two letters: the starting column and the ending one.Machine learningAutomatic players can learn to play better by memorizing its experience in Excel
files (the format was chosen as an example of using Python with spreadsheets).With the command:lex_game -e2 exapawn-empty.xlsx exapawn-001.xlsxplayer 2 plays with the experience found inexapawn-empty.xlsx, at the end of
the match, all the learned experience is saved inexapawn-001.xlsx.It is possibile to make two automatic player play one against the other, seelearn1vs2.shfor a match with several games. After a dozen of games, player2
becomes unbeatable. This is a typical trend for a match with 30 games.gamePlayer 1Player 2112233431532633734835945104611561257136714681569166101761118612196132061421615226162361724717257182671927720287212972230723The game can also be solved deterministically. Seetree-solvedfor a spoiler of the three pawns version. With
four or five paws for each player the game tree is much bigger, but nevertheless
it can be produced by the program in a few minutes.ReferencesSee:https://www.gwern.net/docs/rl/1991-gardner-ch8amatchboxgamelearningmachine.pdf
Package: lexica-api
LLM'sfromlexicaimportClient,languageModelsdefmain(prompt:str)->dict:client=Client()response=client.palm(prompt,languageModels.palm2)returnresponseif__name__=="__main__":print(main("hello world"))Upscale an image.fromlexicaimportClientdefmain(image:bytes)->bytes:client=Client()imageBytes=client.upscale(image)withopen('upscaled.png','wb')asf:f.write(imageBytes)if__name__=="__main__":image=open('examples/images/image.png','rb').read()main(image)Anti-NSFWfromlexicaimportClientdefmain(image_url:str)->dict:client=Client()response=client.AntiNsfw(image_url)ifresponse['content']['sfw']==True:return"This image is safe for work."else:return"This image is not safe for work."if__name__=="__main__":print(main("https://graph.org/file/13e95c6cc932530823391.png"))
Package: lexica-arts
Модульlexica_artsпредоставляет классImage, который используется для генерации изображений с помощью API-сервиса Lexica. Для использования модуля необходимо установить библиотеки aiohttp и Pillow (библиотека для работы с изображениями).Класс Image содержит метод generate, который принимает два параметра:promptиnegative. Параметрpromptсодержит описание изображения, которое необходимо сгенерировать, а параметрnegativeсодержит негативное описание (необязательно).