Saravanan666/pypi-org huggingface dataset:
Package: lumnisfactors
Hi there 👋Lumnis Crypto Alternative Data APIThe LUMNIS Crypto API provides the most comprehensive factor dataset for crypto assets. We provide the following group of factors:Micro-structural Factors- These are factors derived fromorder book data and trade data. We process terabytes of data to extract the most relevant order book and trade factors that are delivered in real-timeRegime Factors- We provideregime datathat enables users to observe how strategies perform in different conditions of the market. For example, some strategies work better during high volatile regimes. We use proprietary algorithms for effectively determining regimes.This data can be used for backtesting and implementing trading strategies.DocumentationClickhereto view documentation on API usage.Receiving API TokenYou can sign uphereto retreive a lumnis API KeyPleasee-mail meif there is an issue with setting up or retreiving an API Key.Getting StartedPrerequisitesPython version 3 installedInstallationThe package can easily be installed by running the following commandpipinstalllumnisfactorsUsage#Import the packagefromlumnisfactorsimportLumnisFactors#Add your API KEYAPI_KEY=""lumnis=LumnisFactors(API_KEY)#Retrieve a single days worth of datadf_single_date=lumnis.get_single_date_data("vpin","coinbase","ethusd","hour","2022-01-01")#Retrieve multiple days worth of datahistorical_data=lumnis.get_historical_data("vpin","coinbase","ethusd","hour","2022-01-01","2022-02-01")
Package: lumod
Lumped Models (LuMod) for HydrologyLuModis an easy to use set of Lumped Models for hydrological simulation in Python language.Compared with other source codes that pretend to be fast,LuModwas created to facilitate the modeling and the results processing. Moreover, some features ofLuModare compiled withnumbato increase simulation speed.DocumentationFull documentation and examples are available here:LuMod-DocsInstallation is available from PyPI:LuMod projectIf you are not familiar with Python, try our Web Application:LuMod-AppKey FeaturesLuModincorporates well know hydrological models with different structures:MILC: One layer Lumped version of the MISDc model adapted for continous daily simulation.HYMOD: Rainfall-Runoff Model based on the Probability-Distributed Model concept that runs at daily timestep.HBV: Modified version of the Hydrologiska Byråns Vattenbalansavdelning (HBV) model.GR4J: Well known daily rain-runoff model that depends of four parameters.GR2M: Monthly rain-runoff model that depends of two parameters.GR1A: One parameter annual rain-runoff model.MonteCarlo: Random-based simulation for parameters optimization and uncertainty analysis.Quick installationThe easier way to installLuModis usingPyPI:pipinstalllumodBasic ExampleLuModwas thought to be easy to use and compatible with libraries dedicated to DataScience, so it works with Pandas and Matplotlib to facilitate the analysis of simulations.# Import modulesimportlumodfromlumodimporttools# Load example datainfo,forcings=lumod.load_example(2)# Create a modelparameters={"x1":500,"x3":200}# define some parametersmodel=lumod.models.GR4J(area=info.area,lat=info.lat,params=parameters)print(model)# Run your modelsimulations=model.run(forcings,x2=3.0)# modify parameter x2 before start# Validate your modeltools.plots.model_evaluation(forcings.prec,forcings.qt,simulations.qt)CitationComing SoonAuthorMain DeveloperSaúl Arciniega Esparza, Ph.D., Full Time Associate Professor at theFaculty of Engineeringat theNational Autonomous University of Mexico, working on theHydrogeology Group.LinkedIn|Twitter|ResearchGateCollaboratorsChristian Birkel, Ph.D., Full Time Professor and Researcher at the Departament of Geography atUniversity of Costa Rica, and leader of theObservatory of Water and Global Change (OACG).Facebook|ResearchGateAcknowledgmentsFundingTheNational Council of Science and Technology (CONACYT), theLeverhulme Trustand theGerman Academic Exchange Service (DAAD)are thanked for partial funding of this work.
Package: lumos
Generate a slide-deck from a single markdown file. With themes. Inspired by
[cleaver](https://github.com/jdan/cleaver).installTOODpip install lumos. Done.Dependencies (installed along with lumos):[Pystache](https://github.com/defunkt/pystache)useTODO: documentationhelpTODO: helpVia–help:futureconfirm dependences installed with pip commandpretty default print stylesheet (for e.g. PDF export)
Package: lumos-sat
lumos-satLumos provides tools for calculating the optical brightness of artificial satellites.More specifically, Lumos allows the user to:Fit analytic BRDFs (bidirectional reflectance distribution functions) to measured data.Create brightness models of satellites.Calculate satellite optical brightness for observers on the ground.Possible use-cases include:Allowing optical brightness to be used as a design constraint by satellite operators.Lets astronomers plan observations based on when and where in the sky satellites are brightest.
Package: lumparser
About LumParserWhat is LumParser?a Python librarya standalone programme where you can interact with luminescence data through a user interfaceIf you perform bioluminescent enzymatic reactions and record the light output over time in a spectrometer, you can use
LumParser to analyze the resulting data. It saves you the hassle of copy-pasting the data in Excel and subtracting the
light background by hand. Plus, you get more options for fitting of data than in Excel.The program was built to take ascii time drive files as input and detecting features of a typical run:An initial phase of around 10s to record the background light, with a luciferase in the reaction mixture.Injection of substrate (luciferin) around 10s into the recording, starting light emission. The entire period in which
light is emitted is referred to as a signal and the initial spike in light as a peak.Slow decay of the light signal over a period of time, which can be fitted to an exponential decay curve.A run can contain several signals if multiple substrate injections are performed, so multiple signals can be detected by
the program.RequirementsPython 3.7Python third-party libraries:matplotlibnumpyscipyInput filesInput time drive files are text files with the extension ".td". The files can contain a header with information. After
the header, a line reading#DATAshould precede the section of the file containing the recorded datapoints.
Data should be in time/value pairs, separated by whitespace. The expected units are seconds (s) for time and relative light
units (RLU) for light emission.Signal detectionThe following rules are used to detect a signal:The start of the signal cannot overlap with the background. So, if the background is measured between 0 and 10s, a
signal start at 9.5s will not be detected.The light emission value should increase by more than the threshold value compared to the average of the last 10
datapoints. So, if the threshold is set to 0.3 and the average of the last 10 datapoints is 5.0, the next datapoint
should have a value of 5.3 or higher for a signal to be detected. The average of the last 10 datapoints before the start
is taken as the baseline.If the light emission dips below baseline withing 100 datapoints after the initial increase, the increase is assumed
to be the result of noise instead of a signal.To make sure that it is always possible to check the rule above, no signal starts can be recorded in the last 100
datapoints in a file.A signal ends at the start of the new signal or at the end of the file.When a signal is recorded and parsed, the background light value is subtracted from all datapoints and the starting
time is set to 0s.InstallingInstall using pip (For installing pip seehttps://pip.pypa.io/en/stable/installation/):pip install lumparserUsing the interfaceOnce the library is installed, run the interface from command line using:python -m lumparserorlumparserImporting the libraryTo import the lumparser library, include the lineimport lumparserat the beginning of a script or module.Maintenance and updatesThe library is provided as-is and will not be maintained or updated after June 2023.
Package: lumpyrem
LumpyremPython package to interact with the LUMPREM software suite. Lumpyrem is very much a work in progress. User beware.If you find a bug or think the software is not working as intended, pleasesubmit an issue.ContributorsRui Hugmanhttps://github.com/rhugmanKevin Hayleyhttps://github.com/khayleyIntroductionLumpyrem is a Python package that facilitates interaction with theLUMPREM lumped-parameter recharge modeland its ancillary programs that assist in setup, and provide a linkage between LUMPREM and MODFLOW 6.
It is intended to make setting up and running LUMPREM models easier, in particular if integrated intoFlopyworkflows.LUMPREM requires daily inputs of rainfall and potential ET. Nonlinear relationships based on stored soil moisture are used to calculate recharge, runoff and actual ET. The parameters which govern these relationships can be adjusted by PEST. Numerous quantities of interest are recorded on LUMPREM’s output file. These include residual daily ET (which can be reformatted for input to the EVT package of MODFLOW), irrigation demand, and boundary condition head. The latter is calculated using a parameterizable, nonlinear relationship between head and stored soil moisture. Heads calculated in this way can be assigned to MODFLOW boundary conditions after appropriate re-formatting.InstallationLumpyrem requires LUMPREM, LUMPREP and LR2SERIES. Executables can be downloaded from thePESTHomepage.org. It is recomended these be placed in a folder in the environment path on your local machine. Alternatively, the executables may be placed within the workspace folder.You can install Lumpyem from PyPi:pip install lumpyremInstalling from the git-hub repository is recommended; the PyPi version lags behind updates in the git-repo.DocumentationDocumentation is a work in progress.Jupyter Notebooks are provided with simple examples of code functionality.LUMPREM and utilities are extensively documented by their developer.To dodeploy documentation to readthedocsutility to read lumprem output and convert to Feflow timeseries/.pow filesutility to write PEST template filesDONEmake OS independentFundingDevelopment of Lumpyrem has been supported in part by the Groundwater Modelling Decision Support Initiative (GMDSI).https://gmdsi.org/
Package: luna
LUNA[1]is an object-oriented Python 3 toolkit for drug design that makes it easy to analyze very large data sets of 3D molecular structures and complexes, and that allows identifying, filtering, and visualizing atomic interactions.LUNA also implements three hashed interaction fingerprints (IFP): Extended Interaction FingerPrint (EIFP), Functional Interaction FingerPrint (FIFP), and Hybrid Interaction FingerPrint (HIFP) – inspired by ECFP[2], FCFP[2], and E3FP[3]. These IFPs encode molecular interactions at different levels of detail, provide several functionalities to trace individual bits back to their original atomic substructures in the context of the binding site, and areRDKit-compatible.Documentation is hosted byReadTheDocs, and development occurs onGitHub.Installation and UsageThe latest stable release (and required dependencies) can be installed as follows:Download LUNA’senvironment.ymlfile.Create the Conda environment using the downloaded file:conda env create -f <LUNA-ENV-FILE>After creating the Conda environment, activate it:conda activate luna-envFinally, install LUNA from Pip:pip install lunaFor additional installation options and usage instructions, refer to thedocumentation.LicenseLUNA is available under theMIT License.References[1]Fassio, A. V.; Shub, L.; Ponzoni, L.; McKinley, J.; O’Meara, M. J.; Ferreira, R. S.; Keiser, M. J.; de Melo Minardi, R. C. Prioritizing Virtual Screening with Interpretable Interaction Fingerprints. J. Chem. Inf. Model. 2022.[2](1,2)Rogers, D.; Hahn, M. Extended-Connectivity Fingerprints. J. Chem. Inf. Model. 2010, 50 (5), 742–754.[3]Axen, S. D.; Huang, X.-P.; Cáceres, E. L.; Gendelev, L.; Roth, B. L.; Keiser, M. J. A Simple Representation of Three-Dimensional Molecular Structure. J. Med. Chem. 2017, 60 (17), 7393–7409.
Package: lunafind
lunafindSearch, filter, inspect, download posts from Danbooru/Safebooru and find them
back from the command line without setting up any service or database.Suitable for daily terminal usage, usable for scripts and as a library
for Python 3.6+.See alsolunasyncto automatically
download and keep in sync particular tags usinglunafind,
similar to Danbooru tag subscriptions or saved searches.FeaturesOperate on tag searches, URLs or file pathsCombine results from multiple searchesSpecify custom page ranges, or just get everythingFilter and order booru results to work around the two tags search limitOptional partial/fuzzy tag matching for filter and local searchesSearch downloaded posts by tags as if they were on a booru, without the
hassle of setting up oneInstant results from local searches in most cases after indexingFast multithreaded downloads; 8 downloads in parallel by defaultSupports operating on post media (image, ugoira WebM, etc), info, notes,
artist commentaries:Getting the URLs or file/folder pathsPrinting on standard outputDownloadingLocal searches performanceThe first time a local post search is done, an index file to speed up future
searches will be automatically created and updated when new post directories
exist or are removed.Test with ~165 000 postsAMD FX-8300 (8 cores, 3.3GHz), TOSHIBA DT01ACA2 7200 RPM HDD,
BTRFS file system, Void Linux 4.18.14 x86_64:It takes about 2m30s - 3m to index everything from scratchAfter this, search results start coming instantly unless--randomor--orderis used.Searches finish completely in 8-20sTest with ~60 000 postsCeleron B815 (2 cores, 1.60GHz), 5400 RPM HDD, BTRFS file system,
Void Linux 4.18.20 x86_64:About 4mn to index everything from scratchResults come instantlySearches finishes in ~20sCommand line usageDownloading to the current folder every post taggedblondeand2girls(default booru ishttps://danbooru.donmai.us):lunafind"blonde 2girls"--limit200--pagesall--download.Searching through the posts we just downloaded,
printing image paths for the results:lunafind"blonde blue_eyes rating:s score:>5"--source.--show-locationmediaSeelunafind --helpfor all options and examples.Python usageNo real documentation yet. Three main classes are provided:Post: represents a local or remote single post, with its info, media, notes
and artcom (artist commentary).Album: works like a dictionary ofPost, where keys are the post IDs.
Has magic methods and operators to facilitate working with them.
Can be filtered, ordered, downloaded, and more.Stream: an efficiant lazy iterator yielding posts.
Can be filtered and multithread-downloaded.Reproducing the command line examples in the section above:fromlunafindimportStreamStream("blonde 2girls",limit=200,pages="all").download()forpostinStream("blonde blue_eyes rating:s score:>5",client="."):print(post.get_location("media"))InstallationRequires Python 3.6+ and pip (for automatic easy install).Tested on GNU/Linux and Windows 7, probably works on OSX and other POSIX
systems.As root:pip3install-Ulunafind
Package: luna-fviz
LunaInspired byLucid,Lunais a Feature Visualization package for Tensorflow.
While Lucid does not support Tensorflow 2,Lunawas built with Tensorflow 2 at its core.Luna is under active development. It is research code and not production-ready.To learn how to use Luna and for insights into its API, see ourdocumentation.ContributingWe greatly appreciate any effort to improveLuna.
If you want to contribute to its development, see ourcontribution guidelines.Recomended ReadingFeature VisualizationThe Building Blocks of InterpretabilityUsing Artiﬁcial Intelligence to Augment Human IntelligenceVisualizing Representations: Deep Learning and Human BeingsDifferentiable Image ParameterizationsActivation AtlasRelated TalksLessons from a year of Distill ML Research(Shan Carter, OpenVisConf)Machine Learning for Visualization(Ian Johnson, OpenVisConf)CommunityWhile we admire their work, we have no affiliation with the Lucid authors or project. Nonetheless, if you are interested in research like this, the Distill slack (join link) might be a good place for you to get to know other people in this area.On the awesome Distill slack, Lucid has its own#proj-lucidchannel, where general questions about the technology are discussed.
Package: luna-ml
Luna MLluna.staroid.com|docsLuna ML: Get your ML models evaluatedLuna ML provides ML model evaluation environment and display evaluation results as well as leaderboard when models are submitted. It works with any ML frameworks you uses and any evaluation criteria you defines.Luna ML is designed with MLOps in mind. Defining projects, evaluation environment and submitting models are done via making Pull requests on the connected GitHub repository. It automates processes using Github action.DocumentationOverview- Why Luna ML, How it works, FAQQuickstart- Install, Setup project repo, submit models and get evaluatedReferences- luna.yaml, model.yaml, project directory structureSee alsoProjectDescriptionluna-mlLuna ML Client - The current repositoryluna-actionLuna ML Github action to automate Pull request review and submit on mergeluna-project-templateTemplate for creating new Github repository for Luna ML ProjectsGetting involvedYou're welcomed ❤️ to leave questions, feedback and ideas!Discord channel-Invite linkIssues- Feel free to create any questions, discussions, bug report.Pull requests- Contribute to Luna ML clientSeeCONTRIBUTINGfor code contribution.
Package: luna-nlg
LUNA: a Framework for Language Understanding and Naturalness AssessmentThe framework provides a set of well-known automated evaluation metrics for text generation tasks.The library includes the following metrics:Blanc:paperMover score:paperBLEU:paperMETEOR:paperROUGE:paperchrF:paperBERTScore:paperBARTScore:paperData statistics metrics:paperCompressionCoverageLengthNoveltyDensityRepetitionROUGE-We:paperS3:paperBaryScore:paperDepthScore:paperInfoLM:paperInstallationInstallation from PyPIInstall it viapip:pipinstallluna-nlgInstallation from the sourceClone the repository and install the library from the root:gitclonehttps://github.com/Moonlight-Syntax/LUNA.git
pipinstall.Another way is to usepoetry. Then, runpoetry installfrom the root.Quick startThe user can either trigger theCalculatorto evaluate metrics or integrate the code itself.CalculatorThe easiest way to evaluate NLG models is to execute the following snippet:fromluna.calculateimportCalculator# Choose to compute in a sequential or a parallel settingcalculator=Calculator(execute_parallel=True)metrics_dict=calculator.calculate(metrics=[depth_score,s3_metrics],# both are LUNA's metricscandidates=candidates,references=references)print(metrics_dict)>>>{"DepthScore":...,"S3":...}Integrate the evaluationsAll the metrics in the library follow the same interface:classMetrics:defevaluate_batch(self,hypothesyses:List[str],references:Optional[List[str]])->List[float]:*somecodehere*defevaluate_example(self,hypothesys:str,reference:Optional[str])->float:*somecodehere*Thus, to evaluate your examples run the following code:fromlunaimportMetricNamemetric=MetricName()result=metric.evaluate_example("Generated bad model by example","Gold example")results=metric.evaluate_batch(["Generated bad model by example 1","Generated bad model by example 2"],["Gold example 1","Gold example 2"])You may find more examples here:examples/metrics.ipynbor in the tests.DevelopmentContribute to the libraryWe are open for issues and pull requests. We hope that LUNA's functionality is wide enough but we believe that it can always be elaborated and improved.Pre-commit hooksWe usepre-commit hooksto check the code before commiting.To install the hooks run the following:pipinstallpre-commit
pre-commitinstallAfter that every commit will trigger standard checks on code style, includingblack,isortetc.TestsTests forlunaare located in thetestsdirectory. To run them, execute:pytesttests
Package: luna-py
LunaOverviewLuna is a string templating engine for Sugari Bot, implemented in Rust with PyO3.InstallationTo install Luna, use the following command:pipinstallluna.pyUsageYou can use Luna with discord.py easily:importdiscordfromdiscord.extimportcommandsfromlunaimportEngine,Adapterintents=discord.Intents.default()intents.message_content=Truebot=commands.Bot(command_prefix='?',intents=intents)@bot.command()@commands.guild_only()# ctx.author.guild won't be Noneasyncdefhello(ctx:commands.Context)->None:adapters=[Adapter.from_member(ctx.author),Adapter.from_server(ctx.guild),Adapter.from_channel(ctx.channel)]output=Engine.process("Hello {member(mention)}! Welcome to our server{server}!",adapters)awaitctx.send(output)bot.run('token')
Package: lunar
A WSGI based webframework.What is Lunar?Lunar是一个玩具式的网络框架，基于PEP333和它的进化版PEP3333，它包括一个模板引擎:https://github.com/jasonlvhit/lunar/blob/master/lunar/template.py一个Sqlite的ORM框架:https://github.com/jasonlvhit/lunar/blob/master/lunar/database.py一个Router，用于请求转发和路由:https://github.com/jasonlvhit/lunar/blob/master/lunar/router.py一个简单的对Request和Response对象的封装查看example来看看这是怎么运作的。lunar is a WSGI based webframework in pure Python, without any third-party dependency.
lunar include a simple router, which provide the request routing, a template engine
for template rendering, a simple wrapper for WSGI request and response, and a ORM framework
for sqlite.Happy hacking.from lunar.lunar import Lunar

@app.route('/', methods = ["GET", "POST"])
def hello():
        return "Hello, lunar!"

if __name__ == '__main__':
        app.run()
Package: lunar-convert
Example PackageThis is a simple example package, for more detail please follow this guide:https://packaging.python.org/tutorials/packaging-projects/Installing virtualenvpython3 -m pip install --user virtualenv
python3 -m virtualenv env
source env/bin/activateUpload package to pypipip install twine
python3 setup.py sdist bdist_wheel
twine upload --repository-url https://upload.pypi.org/legacy/ dist/*
Package: lunardate
Chinese Calendar:http://en.wikipedia.org/wiki/Chinese_calendarUsage>>> LunarDate.fromSolarDate(1976, 10, 1)
LunarDate(1976, 8, 8, 1)
>>> LunarDate(1976, 8, 8, 1).toSolarDate()
datetime.date(1976, 10, 1)
>>> LunarDate(1976, 8, 8, 1).year
1976
>>> LunarDate(1976, 8, 8, 1).month
8
>>> LunarDate(1976, 8, 8, 1).day
8
>>> LunarDate(1976, 8, 8, 1).isLeapMonth
True>>> today = LunarDate.today()
>>> type(today).__name__
'LunarDate'>>> # support '+' and '-' between datetime.date and datetime.timedelta
>>> ld = LunarDate(1976,8,8)
>>> sd = datetime.date(2008,1,1)
>>> td = datetime.timedelta(days=10)
>>> ld-ld
datetime.timedelta(0)
>>> (ld-sd).days
-11444
>>> ld-td
LunarDate(1976, 7, 27, 0)
>>> (sd-ld).days
11444
>>> ld+td
LunarDate(1976, 8, 18, 0)
>>> td+ld
LunarDate(1976, 8, 18, 0)
>>> ld2 = LunarDate.today()
>>> ld < ld2
True
>>> ld <= ld2
True
>>> ld > ld2
False
>>> ld >= ld2
False
>>> ld == ld2
False
>>> ld != ld2
True
>>> ld == ld
True
>>> LunarDate.today() == LunarDate.today()
True
>>> before_leap_month = LunarDate.fromSolarDate(2088, 5, 17)
>>> before_leap_month.year
2088
>>> before_leap_month.month
4
>>> before_leap_month.day
27
>>> before_leap_month.isLeapMonth
False
>>> leap_month = LunarDate.fromSolarDate(2088, 6, 17)
>>> leap_month.year
2088
>>> leap_month.month
4
>>> leap_month.day
28
>>> leap_month.isLeapMonth
True
>>> after_leap_month = LunarDate.fromSolarDate(2088, 7, 17)
>>> after_leap_month.year
2088
>>> after_leap_month.month
5
>>> after_leap_month.day
29
>>> after_leap_month.isLeapMonth
False>>> LunarDate.leapMonthForYear(2023)
2
>>> LunarDate.leapMonthForYear(2022)
NoneLimitsthis library can only deal with year from 1900 to 2099 (in chinese calendar).See alsolunar:http://packages.qa.debian.org/l/lunar.html,
A converter written in C, this program is derived from it.python-lunar:http://code.google.com/p/liblunar/Another library written in C, including a python binding.