Saravanan666/pypi-org huggingface dataset:
Package: hep-ml
hep_mlhep_mlprovides specific machine learning tools for purposes of high energy physics.Main featuresuniform classifiers - the classifiers with low correlation of predictions and mass (or some other variable, or even set of variables)uBoostoptimized implementation insideUGradientBoosting(with different losses, speciallyFlatnessLossis of high interest)measures of uniformity (seehep_ml.metrics)advanced losses for classification, regression and ranking forUGradientBoosting(seehep_ml.losses).hep_ml.nnet- theano-based flexible neural networkshep_ml.reweight- reweighting multidimensional distributions(multihere means 2, 3, 5 and more dimensions - see GBReweighter!)hep_ml.splot- minimalistic sPlot-tinghep_ml.speedup- building models for fast classification (Bonsai BDT)sklearn-compatibility of estimators.InstallationBasic installation:pipinstallhep_mlIf you're new to python and never usedpip, first install scikit-learnwith these instructions.To uselatest development version, clone it and install withpip:gitclonehttps://github.com/arogozhnikov/hep_ml.gitcdhep_ml
pipinstall.Local testing:noseteststests/Linksdocumentationnotebooks, code examplesyou may need to installROOTandroot_numpyto run thoserepositoryissue trackerRelated projectsLibraries you'll require to make your life easier and HEPpier.IPython Notebook— web-shell for pythonscikit-learn— general-purpose library for machine learning in pythonnumpy— 'MATLAB in python', vector operation in python.
Use it you need to perform any number crunching.theano— optimized vector analytical math engine in pythonROOT— main data format in high energy physicsroot_numpy— python library to deal with ROOT files (without pain)LicenseApache 2.0,hep_mlis an open-source library.PlatformsLinux, Mac OS X and Windows are supported.hep_mlsupports both python 2 and python 3.
Package: hep-ml-lab
HEP ML Lab (HML)IntroductionHEP-ML-Lab is an end-to-end framework used for research combining high-energy
physics phenomenology with machine learning. It covers three main parts: the
generation of simulated data, the conversion of data representation, and the
application of analysis approaches.With HML, researchers can easily compare the performance between traditional
methods and modern machine learning algorithms, and obtain robust and
reproducible results.To get started, please check out thedocuments.Installationpipinstallhep-ml-labModule overviewhml.generators: API of Madgraph5 for simulating colliding events;hml.observables: General observables in jet physics;hml.representations: Different data structure used to represent an event;hml.datasets: Existing datasets and helper classes for creating new datasets;hml.approaches: Cuts, trees and networks for classification;hml.metrics: Metrics used in classical signal vs background analysis;hml.utils: Utility functions.Updatesv0.3.0.1Fix a bug that Madgraph5 may run into an infinite loop caused by HML keeping
removing py.py file during initialization.Fix nan value not implemented in Fileter.Fix the wrong order of runs when usinghml.generators.Madgraph5.runsandhml.generators.Madgraph5.summary.Fix the typo "g1" in quickstart.v0.3.0New Madgraph5 API now is closer to the original Madgraph5 CLI.New Observable parsing system makes it easier to use and define new observables.New CutAndCout and BoostedDecisionTree in Keras style.v0.2.2Change output structure ofhml.generators.Madgraph5to ensure reproducibility.Refactorhml.generators.Madgraph5andhml.generators.MG5Runto make
them more robust.v0.2.1Addsummarytohml.generators.Madgraph5to print a summary of all run.Addremovetohml.generators.Madgraph5to remove a run.Addcleantohml.generators.Madgraph5to remove the output directory.
Package: hepos
This is a Python library to convert geographical co-ordinates between
the old GGRS87 (ΕΓΣΑ87) and newer co-ordinate reference systems, using
the HEPOS transformation algorithms described athttp://hepos.gr/.The library at the moment is at an early stage and does not include
the steps that involve corrections with the correction grid. Thus, its
accuracy is at about 1 m.© 2013 Ministry of Environment of GreeceThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, seehttp://www.gnu.org/licenses/.
Package: heppyfwk
Heppy : a python framework for high-energy physics data analysisHeppy (High Energy Physics with PYthon) is a modular python framework for the analysis of collision events.If you're not very familiar with python yet, you will probably find thePython Tutorialuseful before you get started with heppy.Table of contents:
masterInstallationIntroductionA very simple exampleParallel processing: running jobsFull analysis workflowsReference guideGeneric analyses: working in several experimentsPapas, the parametrized particle simulationSupport & feedback:https://github.com/cbernet
Package: heppyness
HeppyHeppy provides pythonic data structures and a few high-level tools for high-energy physics. In particular, it provides very useful histogram classes that neatly integrate systematic variations (which, to my knowledge, no other histogram class that's widely used in HEP does) and support common operations such as addition, division, rebinning, slicing, projecting, integrating. It also provides flexible matplotlib-based plotting.The documentation can be foundhere.This package also provides object conversion from and to ROOT histograms. Reading from ROOT is handled byuprootand therefore doesn't depend on ROOT per se (i.e., you don't need to have [Py]ROOT installed). Converting to ROOT, however, is still done in PyROOT and thus requires a ROOT installation. This could also be ported to uproot at some point, get in touch if you need that.
Package: hep-rfm
Provides tools to manage remote and local files using the XROOTD and/or SSH
protocols.
This allows, for example, to synchronize remote files with those
in a local cluster.
One has to be sure to have the correct rights to access to the sites before using the functions within this module.
This prevents having to introduce their associated passwords many times.InstallationThis package is available on PyPi, so just type:pipinstallhep-rfmTo use thelatest development version, clone the repository and install withpip:gitclonehttps://github.com/mramospe/hep_rfm.gitcdhep_rfmpipinstall.
Package: heprops
hepropsis a simple python package implementing useful properties of the chemical element helium at low temperatureIt includes experimental data and interpolation for the data found in the incredible and useful paper:James S. Brooks and Russell J. Donnelly,The calculated thermodynamic properties of superfluid helium-4,J. Phys. Chem. Ref. Data651 (1977).Most of the data in this paper was available on the late Russel Donnelly's former websitehttp://pages.uoregon.edu/rjdwhich has since been taken offline but it is still available via a 2015 snapshot on theWayBackMachine.The library also implements a number of historical and modern intramolecular interaction potentials for helium atoms.  Details of these are taken from the following papers:R. A. Aziz, V. P. S. Nain, J. S. Carley, W. L. Taylor, and G. T. McConville,An accurate intermolecular potential for helium,J. of Chem. Phys. 70, 4330 (1979).R. A. Aziz, F. McCourt, and C. Wong,A new determination of the ground state interatomic potential for He2,Mol. Phys. 61, 1487 (1987).R. A. Aziz, A. R. Janzen, and M. R. Moldover,Ab Initio Calculations for Helium: A Standard for Transport Property Measurements,Phys. Rev. Lett. 74, 1586 (1995).M. Przybytek, W. Cencek, J. Komasa, G. Łach, B. Jeziorski, and K. Szalewicz,Relativistic and Quantum Electrodynamics Effects in the Helium Pair Potential,Phys. Rev. Lett. 104, 183003 (2010).W. Cencek, M. Przybytek, J. Komasa, J. B. Mehl, B. Jeziorski, and K. Szalewicz,Effects of adiabatic, relativistic, and quantum electrodynamics interactions on the pair potential and thermophysical properties of helium,J. Chem. Phys. 136, 224303 (2012).Supported Python VersionsPython >= 3.6 (for f-strings)InstallationTo install via pip:pip install hepropsOr from within a notebook:importsys!{sys.executable}-mpipinstallhepropsUsageThe package implements two modules:heliumwhich contains a number of functions that return the thermodynamics properties of helium andpotentialwhich implements the pair-potentials.  For example:fromhepropsimporthelium,potentialimportnumpyasnpT=np.linspace(0.5,2.5,5)# the superfluid fractionρsoρ=helium.superfluid_fraction_SVP(T)print(f'ρs/ρ(T) ={ρsoρ}')# the coherence lengthξ=helium.ξ(T)print(f'ξ(T) ={ξ}Å')# Interaction PotentialV=potential.szalewicz_2012r=np.linspace(2.5,5,1000)rₘ=r[np.argmin(V(r))]print(f'rₘ ={rₘ:6.3f}Å')ρs/ρ(T) = [1.    0.993 0.889 0.447 0.   ]
ξ(T) = [4.11100244e-10 5.21483803e-10 7.56156315e-10 1.86293613e-09 1.24228114e-09] Å
rₘ =  2.968 ÅExamplesA notebook including detailed examples of how to plot and compare the different interaction potentials is included in theexamplesdirectory atexamples/he_potential_examples.ipynb.SupportThe creation of this software was supported in part by the National Science Foundation under Award Nos. DMR-1808440 and DMR-1809027.
Package: hep-spt
TheHigh Energy Physics Statistics and Plotting Toolspackage provides tools to work inHigh Energy Physicsusing general python packages.Main pointsFunctions needed on day-to-day work, like calculating errors, residuals, etc.Classes to create adaptive binned histograms, and some functions to represent them usingmatplotlib.Statistical functions to work with Bayesian/Frequentist approaches.Utilities to handle poissonian and/or weighted histograms.Simple classes to work with the CLs method.A set ofmatplotlibstyles.Considerations:Inputs passed to the functions and classes are usually preferred asnumpy.ndarrayobjects.Plotting functions and classes are designed to work withmatplotlib.Statistical tools are built on top of the standardscipypackage.Installation:This package is available onPyPi, so simply typepipinstallhep-sptto install the package in your current python environment.
Since this package uses the Numpy C API, it is necessary to have Numpy already installed.
If you attempt to install “hep_spt” with no installation of Numpy, an error will be raised.
To use thelatest development version, clone the repository and install withpip:gitclonehttps://github.com/mramospe/hep_spt.gitpipinstallhep_spt
Package: hep-tables
hep_tablesExperiments in tablesIntroductionThis is prototyping accessing hierarchical data and using other backends to process it (likeservicex, etc.).As a side note - this things is severly restricted by lack of a type system or type info. We need to be able to tell the difference between something that is a single item (like jet.pt()) and something that is a sequence (jet.tracks()).Some NotesWe have split the parser into two - one looks for things having to do with LINQ processes, and the other deals with things connected with expressions ("/" or ">" operations). We have to be able to call back and forth between them at the moment. Which might not be ideal. There may be a way to combine them. The problem is that the expression processor has to forward everything to the other and vice versa. Which means you have to touch both. It works, but it will be a little bit of a mess going forward, I suspect.How should we consider parsing these things - there are math expressions and sequence expressions. We should look carefully at the DAG and make sure the two are well seperated.When a user uses a newhistogramfunction (something that comes from outside) there should be an automatic way to let the local render stuff know that a backend needs to be called for it. Right now that is hardwired into the code. And one could think of splitting some of this - as different backends could implement the same thing - so one frontend (like histogram) and then all the backends could implement it.It is pretty clear that we should bring every single loop item forward as part of a tuple, just do it. That way if we need them, they are there, and we don't have to have this complex structure to go back and access them at a later time. Code will be much simpler. And the rendering code is smart enough not to try to render things that aren't needed (at least, in the xAOD backend).Everythign should be typed. And we should use Sequence[xxx] to represent the sequecne, so write our own templated typeWe need to monitor the "depth" we are working on in a sequence. Sequence can be nested,
and some how we need to normalize how we think about that. As you have to nest Select
statements the deeper you go. Currently you can go one or two in this code, this needs
to be something general.
Package: heptapod
Python components of the Heptapod serverHeptapodis the friendly fork of GitLab that brings
Mercurial compatibility in. It is a system with multiple components, involving
several programmation languages, notably Ruby, Go and Python.The purpose of this package is to centralize all Heptapod Python code that is
not (yet) in any other, more generic Python project (Mercurial, its extensions,
general-purpose libraries…), and keep them in a high state of quality.Scope and versioning policyThis Python project is not meant for anything else than being a component of
the Heptapodserver, nor is it the whole of Heptapod, only
the parts that happen to be written in Python.The interdependency with other Heptapod components is very tight, to the point
that the requirements file of Heptapod releases usually completely pins this
project. Starting with version
1.0.0 (for Heptapod 0.17), we are planning to followsemverrules (with PEP 440 for development versions).Python 3 is fully supported since version 0.13.0, tested with 3.7 and 3.8.Python 2 support is deprecatedas of version 1.0.0. Only thetesthelperssubpackage is fully supported for both Python versions,
because it can be used for more general Mercurial related testing.
Python 2 support will be dropped entirely when we will have a new home fortesthelpers.Development guideLaunching the testsWe have unit and integration tests withpytest, they'd be typically
run in a virtualenv:python 3 -m venv venv
source venv/bin/activate
./run-all-testsWe have a 100% coverage policy, that is enforced byrun-all-testsand
therefore by the continuous integration.This full run takes about 20 seconds in our continuous integration, and
usually less than that on developer workstations.Workflow rulesWe follow the Heptapod default workflow. Please make a topic, and submit a
Merge Request.Merge Request Pipelines have to pass, and coverage to stay at 100% for the MR
to be technically acceptable – we can help achieving these results, it's not
mandatory for submitting MRs and gather some feedback.ContentsWSGI serving of repositoriesProvided byheptapod.wsgi(not fully independent yet)Mercurial Hooksheptapod.hooks.check_publish.check_publish:
permission rules about public changesets in pushes.heptapod.hooks.git_sync.mirror:
synchronisation to inner auxiliary Git repository for exposition to GitLabheptapod.hooks.dev_util: useful hooks for debug and developmentMercurial extensionTheheptapodextension will provide specific commands and generally everything
that should be done with full access to Mercurial internals.
Package: heptapod-api-import
Heptapod API ImportThis project is a Python library to perform advanced project import tasks,
leveraging the standard GitLab API.The goal is to provide the means to keep the appropriate authorship and dates.
This toolbox is not meant to perform the necessary user mappings ; instead
it expects application code to provide them.Example use cases:Importing issues from foreign issue trackersImporting a project from a full instance backupIn all cases it will need either an administrator private access token,
or a set of tokens for all relevant users.Some of the most common applications will be provided with the library.
This is especially the case for those that involve only GitLab, as they
allow for easy testing within heptapod/heptapod-tests>.
Package: heputils
heputilsHelper utilities around theScikit-HEP ecosystemfor common tasks in HEPThis library is not meant for wide use and will probably be deprecated in favor of a Scikit-HEP library soon.This library should be viewed as a testing grounds for API design decisions.InstallationIn a fresh virtual environment you can install from PyPI withpython -m pip install heputilsDevelopment releasesIf you want to installunsupporteddevelopment releases you can do so from TestPyPI.Firstinstallheputilslike normal from PyPI to get stable releases of all dependenciespython -m pip install heputilstheninstall the development release ofheputilsfrom TestPyPI with the followingpython -m pip install --upgrade --extra-index-url https://test.pypi.org/simple/ --pre heputilswhich will get the release on TestPyPI that corresponds to the most recent commit onmain.You can of course also install directly from the Git repository "locally" by first cloning the repo and then from the top level of it runningpython -m pip install .ContributingAs this library is experimental contributions of all forms are welcome.
If you have ideas on how to improve the API or conceptually how a library meant to introduce people to the Scikit-HEP ecosystem should be structured please open an Issue.
You are of course also most welcome and encouraged to open PRs.DevelopingTo develop, use a virtual environment.
Once the environment is activated, clone the repo from GitHubgit clone git@github.com:matthewfeickert/heputils.gitand install all necessary packages for developmentpython -m pip install --ignore-installed --upgrade --editable .[complete]Then setup the Git pre-commit hooks by runningpre-commit installAcknowledgementsThis library is built upon the hard work of many people in theScikit-HEP ecosystemand is only possible because of the exchange of ideas and contributions of people working together, across experiments and fields to improve science.
This is not an inevitability, but rather the result of directed thought, time, and effort, to which I am most thankful to have benefited from and have been involved in.RequestsCite the software you use in your papers.
Package: hepy
Happy Experiments in Python (HEPY)中文介绍HE是一个针对命令行实验的管理工具。主要对实验中的三个部分进行管理：实验代码版本管理。对每个实验（Experiment），HE会维护一个代码版本，用户可以随时切换到过去的代码版本进行实验。
对于需要频繁修改代码的实验而言，HE可以节省实验者大量的精力，同时提高了实验的可复现性。实验（超）参数管理。每个实验只有一份代码，但是可能包含多个试验（Trial）。
每个试验的命令行参数不同，命令行参数决定了这次试验的实验参数。HE在每次试验的开始，会记录这次试验的超参数。实验结果的管理。HE可以将实验结果自动保存到对应的实验文件夹下。也支持在实验结果中的评价指标进行正则匹配。安装方式pipinstallhepy或者pipinstallgit+https://github.com/JunguangJiang/Happy-Experiments.git@master使用教程注意事项由于代码版本管理时会复制代码目录下的文件，用户首先需要：创建.heignore文件，这个文件的语法和.gitignore相似。在进行代码版本管理时，会忽略.heignore中匹配的文件。确保所有相对路径的数据文件夹都是软连接。否则复制数据文件夹会消耗大量的资源。正式的教程进入代码目录下初始化heinit在代码目录下会出现文件夹he_workspace。运行一个试验herun--exp${experiment_name}--${script}${experiment_name}是你给这个实验取的名字， ${script}是运行这个实验的脚本。
比如运行herun--exptest--ls-l会得到下列输出Create new experiment: test

Running script: ls -l
total 44
....

Finish experiment: test在he_workspace文件夹下出现了一个新的文件夹test。
test/code中包含了当前时刻的代码。test/0.txt包含了第一次试验的结果。如果不指定实验名称，默认会采用当前的时间作为实验名称。如果指定的实验名称与此前的重复，则会使用过去实验时刻的代码。展示实验结果heshow${experiment_names}
Package: hepynet
HepynetHighenergy physics,python-based, neural-network assistant frameworkIntroductionThe goal of the hepynet: perform DNN related high energy physics analysis tasks with simple config filesforATLAS Analysis: include supports for various ATLAS analysis jobsConfig Driven: all tasks defined by a simple config filePython Based: codes are written in Python, which is the mainstream language for DNN studiesInstallationpipinstallhepynetGPU supportYou can refer toTensorflow GPU supportto set up the environment to use GPU for trainingThis is not mandatory, CPU alone is enough to run hepynetSet Up the WorkspacePlease refer tohepynet_exampleto see how to set up the workspace of hepynet.Release Note - v0.4.2Re-implement auto-tuning functions withRay(currently, support three hyperparameter-tuning algorithms:Ax,HyperOptandHEBO)Minor issues fixes and improvements
Package: her
HER, a new Text FormatSearch informations about the Syntax and Types using theWiki
section.Content tableWhat’s HER?Why shall I use HER?Why HER?Python ModuleInstallationImport ModuleEncode a DictionaryDecode a StringHER classDocumentationWhat’s HER?HER is text format, like XML/Json. The difference is that HER is easier
than others. Just see:- Category -
    >> Array[]
    * Array[] = "Umh, that's pretty good!"Why shall I use HER?As I said before, HER issimpleandeasy to use. You can pass
informations, or better, store informations* and document them.Feel the difference:XML:<christmas><greetings>Merrychristmas!</greetings><greetings>Spam,Python,Eggs</greetings></christmas>HER:- Christmas -
    >> Greetings[]
    * Greetings[] = "Merry christmas!"
    * Greetings[] = "Spam, Python, Eggs"Python ModuleInstallationYou can easily install that module usingpip:pipinstallherOr, if you want to upgrade the module:pipinstall--upgradeherImport ModuleYou must useimport herto import all the HER module.importher...Encode a DictionaryJust use theencodefunction.fromherimportencodeher=encode({'Category':{'hello world':True}})print(her)Output:- Category -
    * hello world = TrueDecode a StringJust use thedecodefunction.fromherimportdecodedictionary=decode("- Category -\n* hello world = True")print(dictionary)Output:{'Category':{'hello world':True}}HER classYou can use theHERclass to call lessencode&decodefunctions and optimize
your codebase. It updates all its attributes
automatically.x=her.HER()x.value={"foo":{"lol":1}}print(repr(x.representation))# Output: '- foo -\n    * lol = 1'You can also pass a parameter (dictorstr):x=her.HER('- foo -\n* lol = 1')print(x.value)# Output: {"foo": {"lol": 1}}y=her.HER({"foo":{"lol":1}})print(repr(x.representation))# Output: '- foo -\n    * lol = 1'
Package: heracles
Heracles - GUI helper for PreSMC ATLASHeracles is a module that simplifies Sidia ATLAS testing tasks.
It provides functions and a GUI to perform procedures like enabling
and disabling Airplane Mode, Wifi, starting and receiving calls,
and changing settings in test devices.FeaturesEnable/disable airplane modeStart and answer phone callsReboot deviceOpen SysDump and ImsLoggerRequirementsuiautomator2, airtest, and their dependenciespython -m pip install -U --pre uiautomator2

python -m pip install -U airtestInstallationAfter installing the prerequisites, just runpython -m pip install heraclesUsageHeracles can be executed as a standalone app. Open from a Windows terminal:heraclesCan be imported as a library, tooimport heracles as hrc
hrc.airplane_mode_on()SupportIf you are having issues, please mail the dev directly.
DEV mail:luarle.sousa@sidia.comLicenseMIT license