Saravanan666/pypi-org huggingface dataset:
Package: rootdescent
RootDescentrootdescent is a Python package for numerical analysis, offering tools for approximating roots and performing numerical integration.Featuresrootdescent currently includes the following classes and methods:RootApproximatorThis class provides methods for finding the roots of functions using various numerical approximation techniques. The available methods are:Bisection method (bisection)Fixed-point iteration (fixed_point_iteration)Regula Falsi method (regula_falsi)Newton-Raphson method (newton_raphson)Secant method (secant)IntegrationThis class provides methods for approximating definite integrals of functions using various numerical integration techniques. The available methods are:Trapezoidal rule (trapezoidal_rule)Simpson's 1/3 rule (simpsons_13_rule)Simpson's 3/8 rule (simpsons_38_rule)UsageHere's an example of how to use rootdescent to approximate the root of a function and the integral of another function:fromrootdescentimportRootApproximator,Integration# Define the functions for root approximation and integrationdeff(x):returnx**2-4defg(x):returnx**3-6*x**2+4*x+12# Initialize the RootApproximator and Integration classesroot_approx=RootApproximator()integration=Integration()# Approximate the root of f(x) using the bisection methodroot=root_approx.bisection(f,0,4,error=1e-6,display_iterations=False)print(f"Root:{root}")# Approximate the integral of g(x) using the trapezoidal ruleintegral=integration.trapezoidal_rule(g,1,4,n=100)print(f"Integral:{integral}")## InstallationToinstallRootDescent,downloadthepackageandrunthefollowingcommandinyourterminalorcommandprompt:Replacemy_functionwithyourdesiredfunctionandadjusttheinitialguessesanderroraccordingtoyourneeds.ContributingContributionsarewelcome!Pleasesubmitpullrequestswithbugfixesornewfeatures.LicenseThisprojectisreleasedundertheMITLicense.
Package: root-directory
root_directoryTired of the Python"Importing files from different folder"mess?This is a no-nonsense utility for importing relative to root. So for a directory structure like that:* your_lib
  * lib.py
* your_main
  * main.py
* .root_directoryYou can now importlib.pyfrommain.pywith the following:import root_directory # This must be before imports relative to root
from your_lib import libThis works as long as the root directory is a git repository or contains.root_directoryin the root.As a bonus, you can find out your root path withroot_directory.get_root()(this returns a pathlib.Path object).Why another library?There are several libraries that do something similar, however as far as I know, they either 1) only find the path, but don't help with importing, or 2) add many unnecessary and heavyweight dependencies.This project has no dependencies.InstallationRunpip install root_directory, python 3.4+ is supported.
Package: root-domain
root-domainThis tool allows to extract the root domain from subdomains.
Useful for parse lists of subdomains and retrieve the root domains.Moreover you also can adjust the depth of the domains extracted with-dand-DSetupTo install:gitclonehttps://gitlab.com/Zer1t0/root-domaincdroot-domain/
python3setup.pyinstallExamplesGet root domain:./root-domain.pya.b.c.d.e.google.com
google.comGet subdomain with depth 2 (first subdomain):/root-domain.pya.b.c.d.e.google.com-d2e.google.comGet subdomains until depth 4:./root-domain.pya.b.c.d.e.google.com-D4google.com
e.google.com
d.e.google.com
c.d.e.google.comGet subdomains with depth between 3 and 4:./root-domain.pya.b.c.d.e.google.com-d3-D4d.e.google.com
c.d.e.google.com
Package: rooted-tree-classifier
DescriptionThis folder contains a program that decides round complexity of homogenous LCL problems on (binary) trees.The program uses three subroutines to determines a problem's complexity.constant_deciderdecides whether a problem is O(1) solvable or it is inherently harderlog_deciderdecides whether a problem is log(n) solvable or it is inherently harderlog_star_deciderdecides whether a problem is log*(n) solvable or it is inherently harderUsageInstall dependencies bypip3 install -r requirements.txt.Runpython -m rooted_tree_classifierand describe (on standard input) constraints of a problem.
For example:Note that one needs to first run the classifier (python -m rooted_tree_classifier) and only afterwards provide an input
on a separate line.python -m rooted_tree_classifier
111Expected output isO(1)python -m rooted_tree_classifier
112 121 122Expected output isO(1)python -m rooted_tree_classifier
121 131 212 323Expected output isO(log*n)python -m rooted_tree_classifier
112 121Expected output isΘ(log n)python -m rooted_tree_classifier
112 123 131Expected output isΘ(log n)python -m rooted_tree_classifier
121 212Expected output isΩ(n)TestsTo execute tests, run the following from the root directory:python -m unittest discover
Package: rootfinding
rootfindingfinds roots by bisecting a bracketing interval until the value of the function can be considered sufficiently close to zero. The scheme differs slightly from the implementation of bisection inSciPy: it is better suited for cases where a maximum acceptable residual is a more useful termination criterion than a tolerance for the argument variable, and can lead to fewer function evaluations overall.The small library also contains functionality to automatically search for a bracket of a root when one is not known. While the library will always start by checking the inputs, it is possible to avoid redundant function calls by providing known values of the function—similarly, objects returned (and exceptions raised) by the library helpfully include function values that may be of interest.rootfindingwas first developed as an internal module of our other projectFronts.To use this library, installrootfindingfromPyPIas$ pip install rootfinding. Alternatively, you may copy therootfinding.pyfile from the source code directly into your project (you must retain the copyright notice and license).Documentation is available onRead the Docs.
Package: root-finding-pkg-thanjira
This package is python module which implementation of root-finding method in one dimensional and multidimensional. The methods that included in this module are Golden section seacrh, Bisection method, Newton-Raphson method, Secant method , Brent method method, newton method in n-Dimensional, Broyden-Fletcher-Goldfarb-Shanno (BFGS), and trust-region Dogleg.
Package: rootfoldersearch
Root Folder SearchThis package finds the root directory of a project by recursively traversing parent directories starting at a given path.I used it to overcome a limitation in Jupyter Notebooks, that doesn't provide the__file__variable that would let me easily find the root folder of a project, regardless the current working directory. You might find it useful in other scenarios.How to useimport rootfoldersearch

# returns a string with the absolute path to the root folder, where Readme.md is located, starting the search in the CWD.
rootfoldersearch.findpath('Readme.md')

# the same, but using a file in a subfolder as reference to find the root directory
rootfoldersearch.findpath('/util/a-file')

# the same, but only tries 3 parent folders recursively (default is 10)
rootfoldersearch.findpath('Readme.md', depth=3)

# starting the search in a specific directory (as opposed to using the CWD)
rootfoldersearch.findpath('Readme.md', cwd='/..')
Package: rootlocker
# RootLocker ProjectThis module permit to simply solve analytic equations in the complex plan. It ensures that all the solutions, along with their order of multiplicity, are recovered. The algorithm used rely on the argument principle and therefore require at least C1 functions.## Getting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.### Prerequisites` This module requires the ad module which provides automatic differentiation easily. `### Installing` The easiest way to install this library is to use pip. `### UseThere are two ways to use this module.In this mode, you can define a function which uses the admath library (loaded by default when importing rootlocker module)import rootlocker as rl                    \# Import rootlocker module along with admath module
bounds= [complex(-2,-1),complex(8,3)]      \# Define the domain of research
def f(x):                                  \# Define the function for wich roots are searched
        return rl.cos(x)+4.0\*rl.sin(2*x)
sols,ms=solve(bounds,func=f,myerr=1e-3)    \# Solve the equation f(x)=0 with the accuracy specified by myerr

ms.plotRoots()                             \# Plot the solutions (uses matplotlib)
ms.printStats()                            \# Prints statctics about the computationB. In order to avoid the use of the ad module, one ca provide an equationprovider by overriding the classEqProvider.
For instance, one can directly use custom C or C++ code for the function and its derivative and this permits to significantly reduce the computational time required by the algorithm.## AuthorsMaxence Miguel-Brebion- (IMFT)## LicenseThis project is licensed under the MIT License - see the LICENSE.txt file for details## AcknowledgmentsLaurent Selle, Thierry Poinsot and Emilien Courtine from The Institut de Mecanique des Fluides de Toulouse have greatly contributed to the algorithm behind the rootlocker module.
Package: rootmeapi
# RootMe API[![Build Status](https://api.travis-ci.org/RemiGascou/rootmeapi.svg?branch=main)](https://api.travis-ci.org/RemiGascou/rootmeapi.svg?branch=main)
[![PyPi Version](https://d25lcipzij17d.cloudfront.net/badge.svg?id=py&type=6&v=1.1&x2=0)](https://pypi.org/project/rootmeapi/)## Installation`python python3-mpip install rootmeapi `## RequirementsYou need to have a valid account onhttps://www.root-me.org## Quick examplesIf you want to be able to connect to CTF-ATD rooms from a VPS, you need to be connected so your IP is whitelisted. To do this, you can use this oneliner :` python3-c"__import__('rootmeapi').RootMeAPI().login('YourUsername')"`It will prompt you for you password.
Package: root-numpy
root_numpy is a Python extension module that provides an efficient interface
betweenROOTandNumPy.
root_numpy’s internals are compiled C++ and can therefore handle large amounts
of data much faster than equivalent pure Python implementations.With your ROOT data in NumPy form, make use of NumPy’sbroad library, including fancy indexing,
slicing, broadcasting, random sampling, sorting, shape transformations, linear
algebra operations, and more. See thistutorialto get started.
NumPy is the fundamental library of the scientific Python ecosystem. Using
NumPy arrays opens up many new possibilities beyond what ROOT offers. Convert
your TTrees into NumPy arrays and useSciPyfor
numerical integration and optimization,matplotlibfor plotting,pandasfor data analysis,statsmodelsfor statistical modelling,scikit-learnfor machine learning, and perform
quick exploratory analysis in aJupyter notebook.At the core of root_numpy are powerful and flexible functions for convertingROOT TTreesintostructured NumPy arraysas well as converting
NumPy arrays back into ROOT TTrees. root_numpy can convert branches of strings
and basic types such as bool, int, float, double, etc. as well as
variable-length and fixed-length multidimensional arrays and 1D or 2D vectors
of basic types and strings. root_numpy can also create columns in the output
array that are expressions involving the TTree branches similar toTTree::Draw().
Package: root-pack
Root Extractor Module for MalayalamExtracting root of a word is vital in the preprocessing stage of most Language processing systems for Malayalam. The root extraction module can derive the root of any given words regardless of the number of suffixes or words attached with the stem.RequirementPython3InstallationYou may create a virtual environment for installing the package.python -m venv ENV_DIR
source ENV_DIR/bin/activateand install the root extractorpip install root-packOtherwise, usepip install --user root-packImplementation methodAfter installation, you can import the module to utilize the root() functionimport root_pack
root_pack.root(wordi)The above code will output the root of the input wordwordi. The input word must be given in Malayalam.For example,if you need to find the root of the word "മകന്റെയുമാണെന്നാണ്", you may follow the below stepsimport root_pack
root_pack.root("മകന്റെയുമാണെന്നാണ്")Output:മകന്‍Advantages of the extractorSandhi rules are taken into considerationRules are generalized rather than explicitly specifying each in the codeRecursive functions introduced and thus aids to strip any number of suffixes attached with easeAccuracy rate is quite highAuthorJincy Baby
Package: rootpy
Python has become the language of choice for high-level applications where
fast prototyping and efficient development are important, while
glueing together low-level libraries for performance-critical tasks.
ThePyROOTbindings introducedROOTinto the world of Python, however, interacting
with ROOT in Python should not feel like you are still writing C++.The rootpy project is a community-driven initiative aiming to provide a more
pythonic interface with ROOT on top of the existing PyROOT bindings. Given
Python’s reflective and dynamic nature, rootpy also aims to improve ROOT design
flaws and supplement existing ROOT functionality. The scientific Python
community also offers a multitude of powerful packages such asSciPy,NumPy,matplotlib,scikit-learn,
andPyTables,
but a suitable interface between them and ROOT has been lacking. rootpy
provides the interfaces and conversion mechanisms required to liberate your
data and to take advantage of these alternatives if needed.Key features include:Improvements to help you create and manipulate trees, histograms, cuts
and vectors.Dictionaries for STL types are compiled for you automatically.Redirect ROOT’s messages through Python’s logging system.Optionally turn ROOT errors into Python exceptions.GetandSetmethods on ROOT objects are also properties.Easy navigation through ROOT files. You can now access objects withmy_file.some_directory.tree_name, for example.Colours and other style attributes can be referred to by descriptive strings.Provides a way of mapping ROOT trees onto python objects and collections.Plot your ROOT histograms or graphs withmatplotlib.Conversion of ROOT trees intoNumPyndarraysandrecarraysthrough the relatedroot_numpypackage.Conversion of ROOT files containing trees intoHDF5format withPyTables.roosh, a Bash-like shell environment for the ROOT file, very useful for
quick ROOT file inspection and interactive plotting.rootpy, a command for common tasks such as summing histograms or drawing
tree expressions over multiple files, listing the contents of a file,
or inspecting tree branches and their sizes and types.
Package: root-relative
Tool for running CWD-agnostic Python scripts.With this module you can run your script fromany project nested folder without breaking your imports(including relative imports).pipinstallroot-relative
python-mroot_relativepackage1.module1This line will try to find the module automatically and detect the project root folder based on the module name provided.
After that the CWD is automatically changed and the module is run as-a-module from the project root.Also, there is a fix for relative import uncertainty.If there a/b/c/d and a/b are both added to the sys.path. As a result, if you have a module inside a/b/c/d - you will have two options to import this moduleimporta.b.c.d.module# orimportc.d.moduleThe both options will import the module but relative imports will work differently for them.In the first case you can easily usefrom...importanother_modulebut for the second case you'll haveImportError:attemptedrelativeimportbeyondtop-levelpackage
Package: root-report
root_reportSimple python package to create HTML report out of Cern ROOT scripts.Examplefrom root_report import Report 
import ROOT

ROOT.SetBatch(1) 

report = Report ( "name_of_the_report", "/some/browser-accessible/path/" ) 
report.outputTitle ( "Title of the Report" )

f1 = ROOT.TF1 ( "parab", "x**2", -1, 1)
f1.Draw()

report.outputCanvas ( "figureIdentifier" ) 
report << "Some <B>HTML</B> description here. " << report.br 

report.close()
Package: root-solver
root-solver provides solvers for polynomials of orders 2 and 3 (with plans for 4
and possibly higher), using the algorithms of Kahan and others. Seehttp://www.cs.berkeley.edu/~wkahan/Math128/Cubic.pdffor more information about
the algorithms included.Additionally root-solver includes support for tracking a single root as the
coefficients of the polynomial changes.
Package: rootsstyle
rootsstyleA matplotlib styling package for clean, minimal dataroots themed plots.
Works with any visualization tools that builds upon Matplotlib (seaborn, pandas).InstallationusingpippipinstallrootsstyleusingpoetrypoetryaddrootsstyleUsageExamplesimportrootsstyleimportmatplotlib.pyplotaspltplt.style.use(rootsstyle.style)y,y2=[3,8,1,10],[8,3,10,2]plt.plot(y,label='y')plt.plot(y2,label='y2',linestyle='dotted')rootsstyle.ylabel('yvalues')plt.xlabel('x-label')rootsstyle.legend()plt.title('Example plot')plt.show()importrootsstyleimportmatplotlib.pyplotaspltplt.style.use(rootsstyle.style)languages=['C','C++','Java','Python','PHP']students=[23,17,35,29,12]plt.bar(languages,students)plt.xlabel('Language')rootsstyle.show_bar_values()plt.title('Example barplot')plt.show()STYLINGimportrootsstyleimportmatplotlib.pyplotasplt# globallyplt.style.use(rootsstyle.style)# within context managerwithplt.style.context(rootsstyle.style):# ...FUNCTIONSPlace the legend to the right of the plot.For lineplots, place the legend entries right of the corresponding line.rootsstyle.legend(handles=None,labels=None,title=None)Place the y-label above the y-axis and rotate it, so that it is horizontal.rootsstyle.ylabel(ylabel:str)Show barvalues at each bar.Removes the y-axis (optional).Bar values can be shown just 'below' the top of each bar, or just 'above' each bar.rootsstyle.show_bar_values(remove_y_axis=True,fontsize=12,position="below",fmt="{:.0f}")COLOR PALETTEThe color palettes are added to the global matplotlib color registry. You can thus easily use a palette by simply providing the name in the correct location.VERSIONINGAsemantic versioningscheme is used to update the version on the commit messages. This happens automatically on any push to the main branch. Only patches, minor and major changes will generate a tag, release and publishing of the package. We stick to the defaultAngular Commit Message Conventions. To use this system, commit messages should adhere to a couple of rules:Commits must follow the following syntax<type>(<scope>): <subject>
<BLANK LINE>
<body>
<BLANK LINE>
<footer>Type should be one of the following:feat: A new featurefix: A bug fixdocs: Documentation only changesstyle: Changes that do not affect the meaning of the code (formatting, missing semi-colons, etc)refactor: A code change that neither fixes a bug nor adds a featureperf: A code change that improves performancetest: Adding missing or correcting existing testschore: Changes to the build process or auxiliary tools and libraries such as documentation generationBody (optional) is used to motivate the changeFooter (optional) is used to link to anyissuesthat the commit closes and forbreaking changes, in which case the line should start withBREAKING CHANGE:.CHANGELOGTheCHANGELOG.mdfile is automatically updated upon any new releases.LicenseThis project is licensed under the terms of the MIT license.
Package: root-tissue-seg-package
Root-Tissue-Segmentation PackagePrediction package for reproducible U-Net models, trained for semantic segmentation of microscopy images of root tissue fromA. thaliana(https://github.com/qbic-pipelines/root-tissue-segmentation-core/). These models are trained using the mlf-core framework and tested for reproducibility. This package can be deployed within an analysis pipeline as a module for root tissue segmentation (rts) of fluorescence microscopy images.Free software: MITDocumentation:https://rts-package.readthedocs.io.Package ToolsSegmentation prediction CLI:rts-predUncertainty of prediction CLI:rts-pred-uncertInput feature importance (Guided Grad-CAM) CLI:rts-feat-impUsage Examplesrts-pred-i./brightfields-o./predictions-mmark1-PHDFM-u2net-model.ckpt--suffix""rts-pred-uncert-i./brightfields-o./predictions-mmark1-PHDFM-u2net-model.ckpt--suffix""-t5rts-feat-imp-i./brightfields-o./predictions-mmark1-PHDFM-u2net-model.ckpt--suffix""-t2CreditsThis package was created withmlf-coreusingcookiecutter.ChangelogThis project adheres toSemantic Versioning.1.0.0 (2021-08-10)AddedFixedDependenciesDeprecated0.1.0 (2021-08-10)AddedCreated the project using mlf-coreFixedDependenciesDeprecated
Package: rootutils
rootutilsA simple python package to solve all your problems with pythonpath, working directory, file paths, module imports and environment variables.Why rootutils?Problem:I would like to be able to:Run my python scripts from anywhereAlways import python modules relatively to the project root directoryAlways access files relatively to the project root so I don't have to specify a series of../to get to the dataAlways have access to environment variables from.envfile without having to load them manuallyHave all the above benefits in notebooks even if they're nested in subdirectoriesSolution:Therootutilspackage provides a flexible way to setup the python project with a simple one-liner. It finds the project root based on the location of specified file name, e.g..project-rootor.git.The package is tiny and continuosly maintained.SetuppipinstallrootutilsUsageimportrootutils# find absolute root path (searches for directory containing .project-root file)# search starts from current file and recursively goes over parent directories# returns pathlib objectpath=rootutils.find_root(search_from=__file__,indicator=".project-root")# find absolute root path (searches for directory containing any of the files on the list)path=rootutils.find_root(search_from=__file__,indicator=[".git","setup.cfg"])# take advantage of the pathlib syntaxdata_dir=path/"data"assertdata_dir.exists(),f"path doesn't exist:{data_dir}"# set root directoryrootutils.set_root(path=path# path to the root directoryproject_root_env_var=True,# set the PROJECT_ROOT environment variable to root directorydotenv=True,# load environment variables from .env if exists in root directorypythonpath=True,# add root directory to the PYTHONPATH (helps with imports)cwd=True,# change current working directory to the root directory (helps with filepaths))Simplest usage with one-liner (combinesfind_root()andset_root()into one method):importrootutilsroot=rootutils.setup_root(__file__,dotenv=True,pythonpath=True,cwd=False)DefaultsDefault root indicators (used when you don't specifyindicatorarg):[".project-root","setup.cfg","setup.py",".git","pyproject.toml"]Autorootautorootis an experimental package that reducesrootutilsto single import, without the need to execute any setup calls. This means just the act of importing this dependency (import autorootcwd) causes execution of recurrent search for.project-rootfile.Installation:pipinstallautorootautorootcwdThis adds root folder to pythonpath, sets PROJECT_ROOT env var, and loads variables from.env:importautoroot# root setup, do not deleteThis also changes working directory to root:importautorootcwd# root setup, do not deleteAutoroot exist for convenience and speed. For example, it's faster to just addimport autorootcwdat the beginning when creating new notebook.Package page:https://github.com/ashleve/autorootInspirationsThis package is heavily inspired by:https://github.com/chendaniely/pyprojroothttps://github.com/pashminacameron/py-repo-roothttps://github.com/EduardKononov/from-root