Saravanan666/pypi-org huggingface dataset:
Package: llnl-ibis
IBISLLNL's Interactive Bayesian Inference and Sensitivity, or IBIS, is designed to be used after a number of simulations have run to completion, to predict the results of future simulation runs.Assessment of system performance variation induced by uncertain parameter values is referred to as uncertainty quantification (UQ). Typically, the Monte Carlo method is used to perform UQ by assigning probability distributions to uncertain input variables from which to draw samples in order to calculate corresponding output values using surrogate models. Based on the ensemble of output results, the output distribution should statistically describe the output's uncertainty.Sensitivity analysis refers to the study of how uncertainty in the output of a mathematical model or system can be attributed to different sources of uncertainty in the inputs. In the data science space, sensitivity analysis is often called feature selection.In general, we have some function $f$ that we want to model. This is usually some sort of computer simulation where we vary a set of parameters $X$ to produce a set of outputs $Y=f(X)$.
We then ask the questions, "How does $Y$ change as $X$ changes?" and "Which parts of $X$ is $Y$ sensitive to?", this is often done so that we can choose to ignore the parameters of $X$ which don't affect $Y$ in subsequent analyses.The IBIS package contains 7 modules:filterlikelihoodsmcmcmcmc_diagnosticssensitivitypce_modelplotsGetting StartedTo get the latest public version:pipinstallibisTo get the latest stable from a cloned repo, simply run:pipinstall.Alternatively, add the path to this repo to your PYTHONPATH environment variable or in your code with:importsys
sys.path.append(path_to_ibis_repo)Contact InfoIBIS maintainer can be reached at:eljurf1@llnl.govContributingContributions should be submitted as a pull request pointing to the develop branch, and must pass IBIS's CI process; to run the same checks locally, use:pytesttests/test_*.py
Package: llnl-pydv
PyDVA 1D graphics and data analysis tool, heavily based on the ULTRA plotting tool.PyDV Importable Interface ModuleYou can now call most of PyDV's functionality from within a Python script. Below is an example of how to do this.import sys
    sys.path.append("/usr/gapps/pydv/current")
    import pydvpy as pydvif

    curves = list()
    curves.append(pydvif.span(1,10,6))
    pydvif.save('myFile.txt', curves)DocumentationPyDV Users ManualLicensePyDV is distributed under the terms of theBSD-3 LicenseAll new contributions must be made under theBSD-3 LicenseSeeLICENSEfor details.LLNL-CODE-507071
Package: llnl-themis
ThemisLLNL's Themis is a Python-based scientific workflow ensemble manager for running concurrent UQ simulations on high-performance computers. Using a simple, non-intrusive interface to simulation models, it provides the following capabilities:generating ensemble of simulations leveraging LC's HPC resourcesanalyzing ensemble of simulations outputThemis has been used for simulations in the domains of Inertial Confinement Fusion, National Ignition Facility experiments, climate, as well as other programs and projects.Thethemispackage manages the execution of simulations. Given a set of inputs (sample points) to run a simulation on, this package will execute them in parallel, monitor their progress, and collect the results. Thethemispackage work with Python 2 and 3.InstallationTo get the latest public version:pip install llnl-themisTo get the latest stable from a cloned repo, simply run:pip install .Alternatively, add the path to this repo to your PYTHONPATH environment variable or in your code with:import sys
sys.path.append(path_to_themis_repo)DocumentationThe documentation can be built from thedocsdirectory using:makehtmlRead the Docs coming soon.Contact InfoThemis maintainer can be reached at:domyancic1@llnl.govContributingContributing to Themis is relatively easy. Just send us a pull request. When you send your request, make develop the destination branch on the Themis repository.Your PR must pass Themis' unit tests and documentation tests, and must be PEP 8 compliant. We enforce these guidelines with our CI process. To run these tests locally, and for helpful tips on git, see ourContribution Guide.Themis'developbranch has the latest contributions. Pull requests should targetdevelop, and users who want the latest package versions, features, etc. can usedevelop.Contributions should be submitted as a pull request pointing to thedevelopbranch, and must pass Themis' CI process; to run the same checks locally, use:pytesttests/ReleasesSee ourchange logfor more details.Code of ConductPlease note that Themis has aCode of Conduct. By participating in the Themis community, you agree to abide by its rules.LicenseThemis is distributed under the terms of the MIT license. All new contributions must be made under the MIT license. See LICENSE and NOTICE for details.LLNL-CODE-838977
Package: llnl-thicket
ThicketThicketA Python-based toolkit for analyzing ensemble performance data. You can find
detailed documentation, along with tutorials of Thicket in theReadtheDocs.InstallationTo use thicket, install it with pip:$ pip install llnl-thicketOr, if you want to develop with this repo directly, run the install script from the
root directory, which will build the package and add the cloned directory to
yourPYTHONPATH:$ source install.shContact UsYou can direct any feature requests or questions to the Lawrence Livermore National
Lab's Thicket development team by emailing either Stephanie Brink (brink2@llnl.gov)
or Olga Pearce (pearce8@llnl.gov).ContributingThicket is an open-source project. We welcome contributions via pull requests,
and questions, feature requests, or bug reports via issues.LicenseThicket is distributed under the terms of the MIT license.All contributions must be made under the MIT license. Copyrights in the
Thicket project are retained by contributors. No copyright assignment is
required to contribute to Thicket.SeeLICENSEandNOTICEfor details.SPDX-License-Identifier: MITLLNL-CODE-834749
Package: llog
※下の方に日本語の説明がありますEnglish descriptionThis package a logging tool that doesn't pollute the global scope.How to usefromllogimportLLogtest_log=LLog("./test_log.log")test_log.debug({"msg":"test1"})test_log.debug({"msg":"test2"})test_log.debug({"msg":"test3"})Output result: test_log.log{"date":"2020-09-22 03:32:59.614418","level":"DEBUG","summary_stack":{"function":"<module>","filename":"test_root.py"},"contents":{"msg":"test1"}}{"date":"2020-09-22 03:32:59.616413","level":"DEBUG","summary_stack":{"function":"<module>","filename":"test_root.py"},"contents":{"msg":"test2"}}{"date":"2020-09-22 03:32:59.617411","level":"DEBUG","summary_stack":{"function":"<module>","filename":"test_root.py"},"contents":{"msg":"test3"}}You can check the contents of the log file (the last n entries) as follows:test_log.tail(n=2)Result: standard output (console)[log #1] {
  "date": "2020-09-22 03:32:59.616413",
  "level": "DEBUG",
  "summary_stack": {
    "function": "<module>",
    "filename": "test_root.py"
  },
  "contents": {"msg": "test2"}
}
[log #2] {
  "date": "2020-09-22 03:32:59.617411",
  "level": "DEBUG",
  "summary_stack": {
    "function": "<module>",
    "filename": "test_root.py"
  },
  "contents": {"msg": "test3"}
}日本語の説明ログの設定範囲を細かく管理できるログツール (他ツールのログ設定と競合しない)簡単な使い方fromllogimportLLogtest_log=LLog("./test_log.log")test_log.debug({"msg":"test1"})test_log.debug({"msg":"test2"})test_log.debug({"msg":"test3"})出力結果: test_log.log{"date":"2020-09-22 03:32:59.614418","level":"DEBUG","summary_stack":{"function":"<module>","filename":"test_root.py"},"contents":{"msg":"test1"}}{"date":"2020-09-22 03:32:59.616413","level":"DEBUG","summary_stack":{"function":"<module>","filename":"test_root.py"},"contents":{"msg":"test2"}}{"date":"2020-09-22 03:32:59.617411","level":"DEBUG","summary_stack":{"function":"<module>","filename":"test_root.py"},"contents":{"msg":"test3"}}ログファイルの内容 (末尾n件) を以下のように確認できます。test_log.tail(n=2)結果: 標準出力 (コンソール)[log #1] {
  "date": "2020-09-22 03:32:59.616413",
  "level": "DEBUG",
  "summary_stack": {
    "function": "<module>",
    "filename": "test_root.py"
  },
  "contents": {"msg": "test2"}
}
[log #2] {
  "date": "2020-09-22 03:32:59.617411",
  "level": "DEBUG",
  "summary_stack": {
    "function": "<module>",
    "filename": "test_root.py"
  },
  "contents": {"msg": "test3"}
}
Package: llogpy
[]llogpywhat is llogpy ?llogpy is a open source logging modules developed for people who want to log certain methods in a class
or a function.all you have to do is decorate a function with @logMethod. If you want to log entire class i mean all methods in a class
just decorate with @logClassplease refer to examples on how to use llogpyNote Logging methods dosent works  on static function in classInstallationpipinstallllogpyUsagefromllogpy.llogpyimportlogMethod,logClassclassA(object):def__init__(self):pass@logMethoddefmethod(self):print(" I am a method ")@logMethoddefclsmethod(cls):print(" i am a class method ")if__name__=="__main__":obj=A()obj.method()obj.clsmethod()Example 2fromllogpy.llogpyimportlogMethod,logClass@logClassclassA(object):def__init__(self):passdefmethod(self):print(" I am a method ")defclsmethod(cls):print(" i am a class method ")if__name__=="__main__":obj=A()obj.method()obj.clsmethod()AuthorsSoumil Nitin ShahBachelor in Electronic Engineering |
Masters in Electrical Engineering |
Master in Computer Engineering |Website :https://soumilshah.herokuapp.comGithub:https://github.com/soumilshah1995Linkedin:https://www.linkedin.com/in/shah-soumil/Blog:https://soumilshah1995.blogspot.com/Youtube :https://www.youtube.com/channel/UC_eOodxvwS_H7x2uLQa-svw?view_as=subscriberFacebook Page :https://www.facebook.com/soumilshah1995/Email :shahsoumil519@gmail.comLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for details
Package: ll-orasql
ll-orasql contains utilities for working withcx_Oracle: It allows
calling Oracle procedures via keyword arguments, it wraps the result of
fetch calls in a custom dictionary and it contains some utilitiy functions
and scripts for accessing and copying database metadata.Changes in 1.27.1 (released 03/31/2009)Fixed a bug in the dependency checking forConnnection.itertables.oradeletenow has a new option to usetruncate tableinstead ofdelete from.
Package: llp
llpLiterary Language Processing (LLP): corpora, models, and tools for the digital humanities.QuickstartInstall:pip install llp                       # install with pip in terminalDownload an existing corpus...llp status                            # show which corpora/data are available
llp download ECCO_TCP                 # download a corpus...or import your own:llp import                            # use the "import" command \
  -path_txt mycorpus/txts             # a folder of txt files  (use -path_xml for xml) \
  -path_metadata mycorpus/meta.xls    # a metadata csv/tsv/xls about those txt files \
  -col_fn filename                    # filename in the metadata corresponding to the .txt filename...or start a new one:llp create                            # then follow the interactive promptThen you can load the corpus in Python:importllp# import llp as a python modulecorpus=llp.load('ECCO_TCP')# load the corpus by name or ID...and play with convenient Corpus objects...df=corpus.metadata# get corpus metadata as a pandas dataframesmpl=df.query('1740 < year < 1780')# do a quick query on the metadatatexts=corpus.texts()# get a convenient Text object for each texttexts_smpl=corpus.texts(smpl.id)# get Text objects for a specific list of IDs...and Text objects:fortextintexts_smpl:# loop over Text objectstext_meta=text.meta# get text metadata as dictionaryauthor=text.author# get common metadata as attributestxt=text.txt# get plain text as stringxml=text.xml# get xml as stringtokens=text.tokens# get list of words (incl punct)words=text.words# get list of words (excl punct)counts=text.word_counts# get word counts as dictionary (from JSON if saved)ocracc=text.ocr_accuracy# get estimate of ocr accuracyspacy_obj=text.spacy# get a spacy text objectnltk_obj=text.nltk# get an nltk text objectblob_obj=text.blob# get a textblob objectCorpus magicEach corpus object can generate data about itself:corpus.save_metadata()# save metadata from xml files (if possible)corpus.save_plain_text()# save plain text from xml (if possible)corpus.save_mfw()# save list of all words in corpus and their total  countcorpus.save_freqs()# save counts as JSON filescorpus.save_dtm()# save a document-term matrix with top N wordsYou can also run these commands in the terminal:llp install my_corpus                 # this is equivalent to python above
llp install my_corpus -parallel 4     # but can access parallel processing with MPI/Slingshot
llp install my_corpus dtm             # run a specific stepGenerating this kind of data allows for easier access to things like:mfw=corpus.mfw(n=10000)# get the 10K most frequent wordsdtm=corpus.freqs(words=mfw)# get a document-term matrix as a pandas dataframeYou can also build word2vec models:w2v_model=corpus.word2vec()# get an llp word2vec model objectw2v_model.model()# run the modeling processw2v_model.save()# save the model somewheregensim_model=w2v_model.gensim# get the original gensim object
Package: llpdf
llpdfllpdf is a low-level PDF manipulation library that I originally wrote for
pdfminify, but that has other purposes as well for which I've now made it its
own separate project.llpdf uses its own PDF parser because for the particular purpose of low
manipulation of PDFs, neither PyPDF2 nor pdfrw (which I both tried to use)
seemed particularly suitable. It exposes all the internal structure of a PDF
file to the user and doesn't try to provide any "nice" abstraction. This makes
it very powerful, but also not particularly suitable for end-users. Usages for
llpdf that I've worked with are minifying PDFs (pdfminify!), signing PDFs,
manipulating PDFs (including images and text).Acknowledgmentsllpdf uses the Toy Parser Generator (TPG) of Christophe Delord
(http://cdsoft.fr/tpg/). It is included (tpg.py file) and licensed under the
GNU LGPL v2.1 or any later version. Despite its name, it is far from a toy. In
fact, it is the most beautiful parser generator I have ever worked with and
makes grammars and parsing exceptionally easy, even for people without any
previous parsing experience. If you need parsing and use Python, TPG isthego-to solution I would recommend. Seriously, it's amazing. Check it out.
Copyright and license details can be found in EXTERNAL_LICENSES.md.In order to be able to easily create PDF/A-1b files, pdfminify also includes
the ICC sRGB color profile "sRGB_IEC61966-2-1_black scaled.icc". It is
distributed under its own license which is included in the EXTERNAL_LICENSES.md
file.When signing documents, a Type1 font is included in the resulting PDF in order
to display metadata about the generated signature. As a default font, one of
the Bitstream Charter fonts which was contributed to the X consortium
(Bitstream Charter Serif) is included with pdfminify. It also has its own
copyright and license notice in EXTERNAL_LICENSES.md.Licensepdfminify is licensed under the GNU GPL v3 (except for external components as
TPG, which has its own license). Later versions of the GPL are explicitly
excluded.TPG (Toy Parser Generator), the ICC sRGB color profile and the Bitstream
Charter font fall under their respective licenses (see EXTERNAL_LICENSES.md).
Package: llp-learn
llp-learnLLP-learn is a library that provides implementation of methods for Learning from Label Proportions.Table of ContentsInstallationUsageLicenseInstallationpip install llp-learnUsageimportnumpyasnpfromsklearn.datasetsimportmake_classificationfromsklearn.metricsimportclassification_reportfromllp_learn.dllpimportDLLPfromllp_learn.model_selectionimportgridSearchCVrandom=np.random.RandomState(42)# Creating a syntetic dataset using sklearnX,y=make_classification(n_features=2,n_redundant=0,n_informative=2,n_clusters_per_class=1,n_samples=1000,random_state=42)# Generating 5 bags randomlybags=random.randint(0,5,size=X.shape[0])# Creating the proportionsproportions=np.zeros(5)foriinrange(5):bag_i=np.where(bags==i)[0]proportions[i]=y[bag_i].sum()/len(bag_i)# Labels must be -1 and 1y[y==0]=-1# LLP model (DLLP)llp_model=DLLP(lr=0.0001,n_epochs=1000,hidden_layer_sizes=(100,100))# Grid Search the lr parametergs=gridSearchCV(llp_model,param_grid={"lr":[0.1,0.01,0.001,0.0001]},cv=5,validation_size=0.5,n_jobs=-1,random_state=42)# Train/test splittrain_idx=random.choice(np.arange(X.shape[0]),size=int(X.shape[0]*0.8),replace=False)test_idx=np.setdiff1d(np.arange(X.shape[0]),train_idx)# Fitting the modelgs.fit(X[train_idx],bags[train_idx],proportions)# Predicting the labels of the test sety_pred_test=gs.predict(X[test_idx])# Reporting the performance of the model in the test setprint(classification_report(y[test_idx],y_pred_test))Licensellp-learnis distributed under the terms of theMITlicense.
Package: llpy-helper-lib
LLSE-Python Helper LibA typing & util lib for LLSE Python runtime为 LLSE Python 运行时开发的 类型提示/工具库Install / 安装Usepipor other Python package managers to install globally for type hints.使用pip或其他包管理器全局安装来提供类型提示pipinstallllpy-helper-libor you can use lip to install in global LLSE Pythonsite-packagespath或者使用lip安装到全局 LLSE Pythonsite-packages目录lipillpy-helper-libUsage / 用法example.pyUpdate Log / 更新日志2.13.1Synchronized this library version number with the LL version, also synchronized this library content with LL version 2.13.1补全库版本与 LL 版本同步，且补全库内容与 LL 2.13.1 版本同步Fixed a mistake in the game mode type (T_GameMode)修复 游戏模式类型 (T_GameMode) 中的错误0.2.0Removed modulellpy.utils删除了llpy.utils模块Added things fromBaseLib.py添加了来自BaseLib.py的东西
Package: llqqntinstaller-py
LLQQNTInstaller.py安装git clone https://github.com/kaixinol/LLQQNTInstaller.py.git
cd LLQQNTInstaller.py
pip install poetry
poetry install运行poetry run python3 -m llqqntinstaller  --proxy socks5://127.0.0.1:7890 # 使用socks5代理
# 或
poetry run python3 -m llqqntinstaller  --use-git-proxy # 使用默认git代理
Package: llreval
LLR-Evaluation (llreval)This is an authorized fork fromPYLLR.Python toolkit for likelihood-ratio calibration of binary classifiers.The emphasis is on binary classifiers (for example speaker verification), where the output of the classifier is in the form of a well-calibrated log-likelihood-ratio (LLR). The tools include:PAV and ROCCH score analysis.DET curves and EERDCF and minDCFBayes error-rate plotsCllrMost of the algorithms in LLR-Evaluation are Python translations of the older MATLABBOSARIS Tookit. Descriptions of the algorithms are available in:Niko Brümmer and Edward de Villiers,The BOSARIS Toolkit: Theory, Algorithms and Code for Surviving the New DCF, 2013.InstallInstall usingpippipinstallllrevalUsageimportllrevalOut of a hundred trials, how many errors does your speaker verifier make?We have included in the examples directory, some code that reproduces the plots in our paper:Niko Brümmer, Luciana Ferrer and Albert Swart, "Out of a hundred trials, how many errors does your speaker verifier make?", 2011,https://arxiv.org/abs/2104.00732.For instructions, go to thereadme
Package: llsd
llsdOfficial python serialization library forLinden Lab Structured Data (LLSD).UseInstallllsdwith pip:pip install llsdUsellsdto parse/format your data:importllsddata={"foo":"bar"}# Formatdata_xml=llsd.format_xml(data)# >>> '<?xml version="1.0" ?><llsd><map><key>foo</key><string>bar</string></map></llsd>'data_notation=llsd.format_notation(data)# >>> "{'foo':'bar'}"data_binary=llsd.format_binary(data)# >>> '<?llsd/binary?>\n{\x00\x00\x00\x01k\x00\x00\x00\x03foos\x00\x00\x00\x03bar}'# Parsedata=llsd.parse(data_xml)# >>> {'foo: 'bar'}data=llsd.parse(data_notation)# >>> {'foo: 'bar'}data=llsd.parse(data_binary)# >>> {'foo: 'bar'}DevelopRequirements:pre-commitSet up a venv and install development dependencies:python3 -m venv .venv
. .venv/bin/activate
pip install .[dev]Run tests:pytestBenchmarksBenchmarks from commits tomainare publishedhere.
Package: llsd2json
llsd2jsonCLIs to convert betweenLinden Lab Structured Data (LLSD)and JSON.Example:$ echo '<llsd><map><key>name</key><string>Ruth</string></map></llsd>' | llsd2json | jq -r .name
RuthInstall and useInstallllsd2jsonwith pip orpipxpipx install llsd2jsonllsd2jsonusage: llsd2json [-h] [--format {auto,xml,binary,notation}] [input]

Convert LLSD to JSON

positional arguments:
  input                 LLSD string (default: stdin)

options:
  -h, --help            show this help message and exit
  --format {auto,xml,binary,notation}, -f {auto,xml,binary,notation}
                        LLSD formatjson2llsdusage: json2llsd [-h] [--format {xml,binary,notation}] [input]

Convert JSON to LLSD

positional arguments:
  input                 JSON string (default: stdin)

options:
  -h, --help            show this help message and exit
  --format {xml,binary,notation}, -f {xml,binary,notation}
                        LLSD formatNotesConversion between LLSD and JSON is not perfectly bi-directional. JSON does not
support several LLSD data types such asdate,binary,uri, and has no
distinct number types.
Package: llsd-asgi
llsd-asgillsd-asgiadds automaticLLSDcontent negotiation to ASGI applications
(Starlette, FastAPI, Quart, etc.) with a single line of code:app.add_middleware(LLSDMiddleware)The code forllsd-asgiis based onmsgpack-asgi, a similar middleware
library for theMessagePackbinary format.InstallationInstall with pip:pip install llsd-asgiQuickstart (FastAPI)You can usellsd-asgiwithFastAPIlike so:fromfastapiimportFastAPIfromllsd_asgiimportLLSDMiddlewareapp=FastAPI()app.add_middleware(LLSDMiddleware)Quickstart (Starlette)As a lower level example usingStarlette:fromllsd_asgiimportLLSDMiddlewarefromstarlette.applicationsimportStarlettefromstarlette.responsesimportJSONResponsefromstarlette.routingimportRouteasyncdefhomepage(request):returnJSONResponse({"hello":"world"})app=Starlette(debug=True,routes=[Route('/',homepage),])# Wrap your application with the LLSD middlewareapp=LLSDMiddleware(app)How it worksflowchart TD
    A(Client) <-->|LLSD| B(LLSDMiddleware)
    B <-->|JSON| C(App)Your ASGI application is wrapped around theLLSDMiddleware, which performs
content negotiation based onContent-TypeandAcceptHTTP headers.Quirks modePassingquirks=Trueto the middleware enables 🤪quirks mode. The behavior
of this mode matches that of poorly behaved Linden Lab services, where the
server returns LLSD even if the client has not requested it.
Package: llsi
llsiLightweight Linear System Identification package.llsi offers easy acess to system identification algorithms. Currently implemented are "n4sid", "PO-MOESP", and a prediction error method for state space identification ("PEM_SS") It only depeds on numpy, scipy and optionally matplotlib.UsageIdentificationLoad data
start with loading the heated wire dataset (found in the data/ folder at the root of this repo) using numpyimportnumpyasnpd=np.load('heated_wire_data.npy')Create a SysIdData objectimportllsidata=llsi.SysIdData(t=d[:,0],Re=d[:,1],Nu=d[:,2])the three data series are time (t), Reynolds number (Re) and Nußelt number (Nu). We are going to model the dynamics of the Nußelt number (heat transfer from wire to surrounding fluid) using Reynolds number (velocity of the surrounding fluid) as input.
3. Ensure the time steps are equidistant and the sampling rate is reasonable. Moreover, the beginning of the time series (transient start) is removed and finally the series are centerd around their respective mean value (which is a requirement for linear systems).data.equidistant()data.downsample(3)data.crop(start=100)data.center()Identify a state space model with order 3 using the "PO-MOESP" algorithm.mod=llsi.sysid(data,'Nu','Re',(3,),method='po-moesp')Use it further with scipy by exporting it to a scipy.signal.StateSpace objectss=mod.to_ss()or to a continuous time transfer functionss=mod.to_tf(continuous=True)PlottingOptionally, if matplotlib is installed, simple plots can be created using the llsi.Figure context manager:withllsi.Figure()asfig:fig.plot(ss,'impulse')will plot the impulse response of the model ss.ContributionThank you for considering to contribute. Any exchange and help is welcome. However, I have to ask you to be patient with me responding.