Saravanan666/pypi-org huggingface dataset:
Package: lotr-movie-sdk
lotr_movie_sdk packageSubmoduleslotr_movie_sdk.movie moduleLord Of The Rings Movie SDK, based on the api exposed by:https://the-one-api.dev/.classlotr_movie_sdk.movie.Movie(key, url='https://the-one-api.dev/v2')Bases:object_init_(key, url='https://the-one-api.dev/v2')Initialization of the movie SDK that sets the api key & URL of the endpoint.Args:key (str): String representing the api key.
url (str): Optional parameter - a string representing the base URL for the API endpoint

> (defaults to [https://the-one-api.dev/v2](https://the-one-api.dev/v2)).Examples:```python
>>> hello("Roman")
'Hello Roman!'
```get(id)Get the metadata of a movie with the specified id.Args:id (str): String representing the movie id.Returns:Dict: movie detailsExamples:```python
>>> m.get("345t453t3")
'{"_id":"345t453t3","name":"movie1",....}'
```Return typedictlist()Get list of all the movies with their metadata.Returns:List: list of movies with their metadataExamples:```python
>>> m.list()
'[{"_id":"45t5t45t454",'name':'movie1',....},...]'
```Return typelistquotes(id)List all the quotes of a movie with the specified id.Args:id (str): String representing the movie id.Returns:List: list of movie quotesExamples:```python
>>> m.quotes("345t453t3")
'[{"_id":"34r43r43r","quote":"Hello world"},....]'
```Return typelistModule contentsLord Of TheRings Movie SDK - Test for LibLablotr_movie_sdk.get_version()Return typestr
Package: lotr-one
LOTR SDKThis SDK provides an easy way to integrate the API endpoints of The One API. More information about the API can be found here:https://the-one-api.dev/documentationNoticeThis current version of the SDK does not currently support additional options like pagination, filtering, or sortingUsageDownload the sdk using pippip install lotr-oneImport the SDK client into your projectfrom lotr-one import clientCreate a LOTR client and assign it to a variablelotr = LOTR()Start making callslotr.get_book()Supported FunctionsSome routes on the API provide the ability to get second-level data. For example, all the chapters from a specific book. This second-level data can be accessed by passingTruealong with the ID of the requested record. The functions to which this applies are outlined below.Function(Parameter=default)get_book(id=None, chapter=False)get_movie()(id=None, quote=False)get_character(id=None, quote=False)get_quote(id=None, quote=False)get_character(id=None)
Package: lotronexyz12-sdk
Cast it into the fire!Runpip3 install lotronexyz12_sdkImport the SDKfrom  lotronexyz12_sdk import LOTR_SDKExamplesclient = LOTR_SDK()

# query the movie endpoint
movie_endpoint = client.endpoint('movie')# Fetch all movies
movies = movie_endpoint.fetch_all()# Fetch all movies with OPTIONS
# limit -> int
# page -> int
# offset -> int
# sort -> str. 
    Sort by movie name -> "name:asc" or "name:desc"

# filter -> str
    - Less than, greater than or equal to.
    - Keys:  academyAwardWins, runtimeInMinutes, and budgetInMillions.
    - Example value: academyAwardWins>10&runtimeInMinutes>=160

movies = endpoint.fetch_all(
    options={
        'limit' : 5,
        #'page' : 2,
        #'offset' : 3,
        'sort' : 'name:asc',
    }, 
    filter = 'academyAwardWins>10&runtimeInMinutes>=160'
)# Fetch a single movie
movies = endpoint.fetch_one(
    '5cd95395de30eff6ebccde5d',     # movie _id
    with_quotes=True,               # return quotes from movie, default is False
    
    options = {                     # Options similar to fetch_all
        'sort' : 'character:desc',  # Sort by movie name or character if with_quotes=True
        'limit' : 5
    }
)
Package: lotrpy
dinesh_ketumakha-SDKThis is the python sdk for accessinghttps://the-one-api.dev/server's endpoints related to Lord Of the Rings movies & quotes.InstallationTo install usingpipdo the following in a virtual environment$ mkdir my_lotr_test_dir
$ cd my_lotr_test_dir
$ python3 -m venv venv
$ pip install lotrpyUsageThe following is how you can use this SDKfrom lotrpy.lotr import LOTR

token = "bearer_token_value"
base_url = "https"//server.com/api/v1"

lotr = LOTR(token, base_url)

# get all movies
lotr.get_movies()

# get all movies on page 2 if there was more than 1 page 
# in the response above
lotr.get_movies(page=2)

# get all movies, limit each response to 5  items
lotr.get_movies(limit = 5)

# get info on a single movie
movie_id = "123lkdlfs"
lotr.get_movie(movie_id)

# get all quotes. paging and limit apply just like above
lotr.get_quotes()

# get all quotes from one specific movie
lotr.get_quotes_from_movie(movie_id)

# get one specific quote. Need to get the quote_id from 
# response of get_quotes()
lotr.get_quote(quote_id)TestingTo run the tests, install pytest in the venv created above$ pip install pytestClone this repo and cd into the root of the directory$ git clone https://github.com/gypsyx/dinesh_ketumakha-SDK.git

$ cd dinesh_ketumakha-SDK
$ pytest # runs all testsTo run just unit tests$ pytest -k unit
Package: lotr-ryankubin
LOTR SDKIf you've ever wanted to have every piece of dialogue from every lord of the rings movie at your fingertips, boy do I have the SDK for you.  With this package, you'll be able to access information on all 6 (yes, even the hobbit trilogy) movies, and every quote therein.PrerequisitesYou'll need python 3 installed.Setup and InstallationTo get started, you'll need to install the lotr_ryankubin packagepip install lotr_ryankubinHow to use itThe key to the whole interaction is to create aLotrobject.  You'll need to initialize this with your access token, which you can obtain by registeringhere.
Once you have your token, initialize your connectionfrom lotr_ryankubin.lotr import Lotr
l = Lotr(access_token='your_token_here')If there is any issue authenticating, this will raise an unauthorized error, and you'll need to check your token to confirm it is correct.From here, you now have access to the two main functions: movies and quotes. When you call a get, the return for all will be in JSON.  Both are able to apply filters and sorts, in the format:
Sort:sort=<field_name>
direction = asc|dscFilter:movie_filter=<fieldname><filterlogic>Where filterlogic can be a regular expression, a comparison, existance, etc.  Review the docs above to see the different formats and available options.To fetch all movies:m = l.movie()
m.get_movies()To fetch movies with an academy award:fancy_m = l.movie(movie_filter='academyAwardWins>0')
fancy_m.get_movies()To fetch all quotes:q = l.quote(movie_id=<movie_id>)
q.get_quotes()Quotes are paginated by default, you can iterate through them by next(), previous(), or setting the limit or offset manually on the quote objectq.next()
q.previous()

q.limit = 100
q.next()
Package: lotr-sdk-iyerland
narayan-sdkPython SDK that makes theLord Of the RingsAPI accessible to other developers. The SDK covers only the movie endpoints:/movie
/movie/{id}
/movie/{id}/quoteDetails of the design can be found inDESIGN.mdThe name of the package islotr-sdk-iyerlandand published to Python Package Index (PyPi).AssumptionsPython3 & Pip3 are already installed on the target machine where this
repo will be cloned and tested.How to test the codeAfter checking out the code and while in project folder, run:python3 -m unittest
Package: lottery-dcl
Stock Analysis Script (Lottery)This Python script analyzes historical stock data stored in a CSV file (orcl.csv). It calculates and writes two technical indicators, the 5-day Simple Moving Averages (SMA) and the 14-day Relative Strength Index (RSI), to separate CSV files (orcl-sma.csvandorcl-rsi.csv).UsageLoad Historical Data:The script first loads historical stock data from a CSV file (orcl.csvin this example). The data is expected to have columns like 'Date', 'Open', 'High', 'Low', 'Close', 'Volume', etc. Make sure to adjust thecsv_file_pathvariable with the correct path to your CSV file.csv_file_path=' '# Add orcl.csv file pathhistorical_data=load_historical_data(csv_file_path)Run the Script:Execute the script to load the historical data, calculate technical indicators, and write the results to CSV files. Run the following command in the command line:pythonscript_name.pyOutput FilesTwo CSV files (orcl-sma.csvandorcl-rsi.csv) will be generated with the calculated SMA and RSI values, respectively.Functionsload_historical_data(file_path):Loads historical stock data from the specified CSV file into a list of dictionaries.calculate_sma(data, window):Calculates the 5-day Simple Moving Averages (SMA) for the given historical data.calculate_rsi(data, window):Calculates the 14-day Relative Strength Index (RSI) for the given historical data using a provided formula.write_to_csv(file_path, header, data):Writes data to a CSV file with the specified header.The Stracture of The File:my-python-project
â”‚â”€â”€â”€README.md
â”‚â”€â”€â”€ setup.py
â”‚â”‚
â””â”€â”€â”€Lotterry
|init.py
â”‚   Lottery.pyExample of Usagecsv_file_path=' '# Add orcl.csv file pathhistorical_data=load_historical_data(csv_file_path)sma_5=calculate_sma(historical_data,window=5)rsi_14=calculate_rsi(historical_data,window=14)sma_header=['Date','SMA_5']sma_data=[[row['Date'],sma]forrow,smainzip(historical_data,sma_5)]write_to_csv('orcl-sma.csv',sma_header,sma_data)rsi_header=['Date','RSI_14']rsi_data=[[row['Date'],rsi]forrow,rsiinzip(historical_data,rsi_14)]write_to_csv('orcl-rsi.csv',rsi_header,rsi_data)print(historical_data[:5])print("5-day SMA:",sma_5[:5])print("14-day RSI:",rsi_14[:5])print("Files 'orcl-sma.csv' and 'orcl-rsi.csv' written successfully.")
Package: lottokit
LottoKitLotto Kit Package is A simple lottery analysis kit>>>fromlottokitimportDaletou>>>t=Daletou()>>>t.download_data()>>>t.fetch_data()>>>t.predict()>>>Installing LottoKit and Supported VersionsLottoKit is available on PyPI:python-mpipinstalllottokitLottoKit officially supports Python 3.6+.API Reference and User Guide available on Read the DocsDocumentation
Package: lotusdesigns
lotusDesignsThis is a utility for the lotusDesignPrints shop.Inputs to the utility is a teplate system that points to background images and various overlay images.
The utility then merges the images together.Getting StartedTo get a local copy up and running follow these simple steps.InstallationRun the following command:pipinstalllotusdesignsLicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactKanelis Elias -@emailPyPi Link:https://pypi.org/project/lotusdesigns/
Package: lotus-nlte
LOTUSLOTUS(non-LTE Optimization Tool Utilized for the derivation of atmospheric
Stellar parameters) is a python package for the derivation of stellar parameters viaEquivalent Width (EW)method with the assumption of1D Non Local Thermodynamic Equilibrium. It mainly applies on the spectroscopic
data from high resolution spectral survey. It can provide extremely accurate
measurement of stellar parameters compared with non-spectroscipic analysis from
benchmark stars.Full documentation atlotus-nlte.readthedocs.ioInstallationThe quickest way to get started is to usepip:python-mpipinstalllotus-nlte==0.1.1Notice thatLOTUSrequires Python 3.7.*. You might create an independent environment to run this code.UsageCheck out the user guides and tutorial docs onthe docs
pagefor details.ContributingLOTUSis an open source code so if you would like to contribute your work please
report an issue or clone this repository to your local end to contribute any changes.AttributionOur paper has been submitted toThe Astronomical Journaland is being peer-reviewed. We also post it on arxiv and we will update citation after being accepted. If you useLOTUSin your research, please cite:@ARTICLE{2022arXiv220709415L,
   author = {{Li}, Yangyang and {Ezzeddine}, Rana},
    title = "{LOTUS: A (non-)LTE Optimization Tool for Uniform derivation of Stellar atmospheric parameters}",
  journal = {arXiv e-prints},
 keywords = {Astrophysics - Solar and Stellar Astrophysics, Astrophysics - Instrumentation and Methods for Astrophysics},
     year = 2022,
    month = jul,
      eid = {arXiv:2207.09415},
    pages = {arXiv:2207.09415},
 archivePrefix = {arXiv},
   eprint = {2207.09415},
 primaryClass = {astro-ph.SR},
   adsurl = {https://ui.adsabs.harvard.edu/abs/2022arXiv220709415L},
  adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
Package: loud
This nose plugin lets you play sound when running your test. Current version
only plays audio files on two instances, when you pass the test, or not (no
option to play sound at individual error/failure).Loud will use these media players to play audio files:Linux/BSD: mpg123Mac OS: afplayWindows: wmplayerUse option –perfect and/or –fail:$ nosetests --perfect ~/godlike.wav
$ nosetests --fail ~/combo_breaker.wav
$ nosetests --perfect ~/guilestheme.mp3 --fail ~/yaketysax.mp3
Package: loudhailer
LoudhailerIntroductionLoudhaileris a python library that allows to send broadcast messages to groups of consumers. It has been designed for being used in asynchronous applications.This initial release natively supports RabbitMQ and Redis backends and can be easily extended to support more backends.Loudhailerincludes an extension that allows you to use in django-channels based projects.Please note that the current version of Loudhailer have to be considered a beta release since it is still under heavy development.InstallLoudhailerrequires python 3.8 or later.Loudhailercan be installed frompypi.orgusing pip:$ pip install loudhailerIf you plan to use it with django-channels you must install the optional channels dependency:$ pip install loudhailer[channels]Basic usagePublishing messagesfromloudhailerimportLoudhailerasyncwithLoudhailer('amqp://localhost')asloudhailer:awaitloudhailer.publish('my_group',{'message':'data'})Subscribe to group and receive messagesfromloudhailerimportLoudhailerwithLoudhailer('amqp://localhost')asloudhailer:withloudhailer.subscribe('my_group')asmessages:message=awaitmessages.get()print(f'received message:{message}')Django channels extensionThe django-channels extension is an implementation of the Channel Layers specifications.In order to properly works it need to add a ASGI lifespan handler to your channels application.Please note that Channel Layers specification are not yet fully implemented, only group messaging is supported in this
initial release.Django settingsAdd the following Channel Layers configuration to your Django settings module:CHANNEL_LAYERS={'default':{'BACKEND':'loudhailer.ext.channels.LoudhailerChannelLayer','CONFIG':{'url':'amqp://localhost',},},}Configure the ASGI lifespan handlerAdd the following configuration to your root channels routing module:fromchannels.routingimportProtocolTypeRouter,URLRouterfromloudhailer.ext.channelsimportLoudhailerChannelLifespanapplication=ProtocolTypeRouter({'lifespan':LoudhailerChannelLifespan.as_asgi(),'websocket':URLRouter(...),},)In case you already have an handler to process lifespanstartupandshutdownevents you can be notified of
such event by theLoudhailerChannelLifespanhandler in two ways:Using django signalsYou can register your signal handler forstartupandshutdownevents in the following way:fromdjango.dispatchimportreceiverfromloudhailer.ext.channelsimportasgi_application_shutdown,asgi_application_startup@receiver(asgi_application_startup)defhandle_startup(sender,**kwargs):pass@receiver(asgi_application_shutdown)defhandle_shutdown(sender,**kwargs):passUsingon_startupandon_shutdownhooksfromchannels.routingimportProtocolTypeRouter,URLRouterfromloudhailer.ext.channelsimportLoudhailerChannelLifespanasyncdefon_startup():passasyncdefon_shutdown():passapplication=ProtocolTypeRouter({'lifespan':LoudhailerChannelLifespan.as_asgi(on_startup=on_startup,on_shutdown=on_shutdown,),'websocket':URLRouter(...),},)Please note that theon_startupandon_shutdownhooks can be implemented both as synchronous or asynchronous functions.LicenseLoudhaileris released under theApache License Version 2.0.
Package: loudify
loudifyRunning a GNU Radio flowgraph in a ZMQ client <-> broker <-> worker setup.Loudify: LoRa cloudifiedExplore the docs »Report a bugRequest a featureSummaryThis project consist of three different parts namely the client that is running a GNU Radio flowgraph, the worker receiving the data and doing the actual demodulation process and the broker connecting the two together.
This repo holds the code for all the parts, be sure to check outgr-lora_sdrto see how this codes integrates into GNU Radio.DocsDocumentation is built automatically on commits, and can be visited by going todocsWhyThis project together with the GNU Radio code located ingr-lora_sdris part of my graduation project which is called a Centralized Radio Acces Network gateway for LoRa.
Its purpose is to research if it is possible to be able to aggregate LoRa packets originating from different LoRa gateways by making a central point (aka the broker) that all gateways can connect to. The overall high level idea is to let LoRa gateways share information on the reception of their signals.InstallingInstalling the project can be done in two ways, by installing the normal PyPi releasepipinstallloudifyOr by installing directly from the repo either by doing pip git installpipinstallgit+https://github.com/martynvdijke/loudify.gitOr by cloning the repo and running flit installpipinstallflit
gitclonehttps://github.com/martynvdijke/loudifycdloudify
flitinstallArchitectureFor a more detailed overview of the entire architecture and to be able to see how everything is connected visitarchitectureContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change. Make sure to add or update tests as appropriate.Changelog
Package: lounge
LoungeCLI tool that sets up your development environment for contributing with one line commandPrerequisiteFork the repo you are wishing to contribute.ObjectivesRun a simple command likelounge reactthat:Clones repository that you forked from your GitHub accountRuns all the shell commands needed to set you up for development (i.e: cd repo, npm install, npm run tests). Based on a predefined recipe in LoungeFor corporates and private projects. You could define the recipe in your private project. With a usage likelounge --repo <your-private-project> --recipe-file <file-name>With the hopes that you should then be ready to submit your first pull request faster
Package: loupiotes
loupiotes: a Bayesian starspot modelling toolWhat is loupiotes ?Using modern sampling method enabling GPU scaling,loupiotesis
mainly dedicated to perform Bayesian starspot modelling.
Building upon the powerful framework provided by thePyMCframework,
it implements starspots model exploration through
Maximum a-posteriori (MAP) analysis and Hamiltonian Monte-Carlo
(HMC) sampling.Getting startedPrerequisitesloupiotesis written in Python3.
The following Python package are necessary to use it :pymcarviznumpyscipymatplotlibnumbatqdmInstallationloupiotesdoes not have a PyPI or conda-forge packaged version yet.
You will have to clone the online repository and run at the root of
the downloaded directory:pip install .DocumentationAnonline documentationwith tutorials and API description is available.AuthorSylvain N. Breton- Maintainer - (INAF-OACT, Catania, Italy)AcknowledgementsIf you useloupiotesin your work, please provide a link to
the GitLab repository.ReferencesThe models implemented byloupiotesare described in the following publications:Lanza et al. (2007), Astronomy & Astrophysics, 464, 741L.Lanza (2016), Cartography of the Sun and the Stars, Lecture Notes in Physics, Volume 914.
Package: loutilities
This is a package with a few hopefully useful utilities.agegrade - provide age grading calculations (running)apikey - manage API keys for an applicationbfile - binary file handlerconfigparser - enhanced ConfigParser, provides dict and keys are case sensitivecsvu - csv and string utilitiescsvwt - write csv from various file typesextconfigparser - extend ConfigParser.RawConfigParser option interpretationgeo - utilities for lat / long and other geographic manipulationgoogleauth - oauth 2.0 for google APIskmlutils - utilities for access to kml filenamesplitter - name splitting methodnesteddict - handle dict keys like d[‘a.b.c’] as d[‘a’][‘b’][‘c’]nicknames - name equivalence detectorrenderrun - common functions for rendering information related to runningtables - utilities for dataTables javascript supporttables-files - supporting files required for tables.py – these need to be copied to project using tables.pytextreader - read text out of various file typestimeu - time methodstransform - transformation methodswxextensions - extensions for wxPython widgetsxmldict - xml / dict conversions, fromhttp://code.activestate.com/recipes/573463-converting-xml-to-dictionary-and-back/Command line scriptsagegrade - update age grading table (running)apikey - create / update key for an applicationapplytemplate - apply a template to files in a directoryfiltercsv - filter a csv file based on indicated filtermakerst - make rst files as input for Sphinx documentation for a given packageLicenseloutilities is licensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0)
Package: loutils
LibreOffice UtilsHeadless (command line) operations on Word, Excel, Powerpoint and most otherformats LibreOffice can handlefor:Doc => PDF conversion  (LibreOffice only)printing (to the system default printer only)from Python command line using LibreOffice or Microsoft Word.doc / .docx to PDF conversionConvert a directory of .doc / .docx to .pdf by:python-mloutils.doc2pdf~/DocumentsPrintingCAUTION:The doc2print.py script can print an unlimited number of pages to an unwanted printer, possibly causing great expense or violation of private documents to a public printer. Use great care with these scripts, preferably to a local non-networked printer you are sitting next to.python-mloutils.doc2print~/mydocsThe-exeparameter allows selecting the printing program.
The script does not check that the files can be printed appropriately, it just prints.
Thus use the-sparameter to select only the suffixes wanted.
For example to print all Markdown files in a directory with Notepad++:python-mloutils.doc2print~/mydocs-s.md-exenotepad++LibreOffice 7.2 finally fixed file globbing, but we use explict for-looping to work with older LibreOffice.
LibreOffice is not thread-safe, so documents are converted or printed one at a time.
Package: louvijan
louvijanlouvijanis a tool to control the script pipeline (not limited to Python scripts), which means that scripts can be executed in a specified order. In addition, it is recommended because it is lightweight, fast and easy to use.Why does it have this strange name? Because it is similar to the pronunciation "li煤shu菒xi脿n" of pipeline in Chinese.InstallationYou can installlouvijanwithpip:pipinstalllouvijanExamplesIn one word, easy to use! After reading, please show your thumb.If you have a series of scripts that need to be executed in a certain order, as shown in the figure:In the figure, A to G represent scripts respectively. First execute A, then execute B, C, D at the same time, then execute E, F at the same time, and finally execute G.Let's describe it with louvijan:fromlouvijanimportPipeLinePipeLine('A',['B','C','D'],['E','F'],'G')()If you want to execute B, C, D on a remote server, you can create a new configuration fileremote.conf:[remote]ip=127.0.0.1port=22username=rootpassword=123456This is the case with louvijan:PipeLine('A',Python(['B','C','D'],config='remote.conf'),['E','F'],'G')()It is able to also send you an email after the script execution succeeds or fails or regardless of success or failure, by adding options in the configuration file like this:[email]host=smtp.qq.comusername=12345port=25authcode=************sender=tanyee@qq.comreceivers=one@qq.com,two@qq.com,three@qq.comsend_mail_flag=alwaysYou can execute the following statement to generate a configuration template file:fromlouvijanimportConfigConfig().template()By setting the configuration file and multiple nested PipeLine, you can construct a variety of complex pipeline projects.Moreover, it can print the information during the scripts running to the log file.For more details, seeexample.py.