Saravanan666/pypi-org huggingface dataset:
Package: reggia
simplisticPackageMetaA base class for creating command line interface (cli) wrappers.What is it?reggiaA pythonic-style library that makes regular expressions (regex) simple... It aims to be a fundamental tool when working with regex in Python.Table of ContentsMain FeaturesWhere to get itDependenciesLicenseDocumentationMain FeaturesHere are just a few of the things that py-rex does well:Provides an intuitive interface to the power of regex.Able to generate identical regex expressions from user logic.Where to get itThe source code is currently hosted on GitHub at:https://github.com/jesse-sealand/reggiaThe latest released version are available at thePython
Package Index (PyPI)only at this time.# PyPIpipinstallreggiaDependenciesNot dependant on packages outside of python core library.LicenseMITDocumentationThe official documentation is hosted onRead the Docs.
Package: reggie
Downloads and DocsFull documentation is available onRead the Docs.Built packages are available onPyPI.Source codeis available onGitHub. Feel free to:Create an issueto request a
feature or a report a bug.Fork the repositoryand make
changes to themasterbranch for next release.Send a pull request and pester the maintainer until it’s merged. Make sure
to add yourself toAUTHORSand updateCHANGES.Build Status
Package: reggisearch
Search for values in regedit$pipinstallreggisearchr""".reg file:Windows Registry Editor Version 5.00[HKEY_LOCAL_MACHINE\SOFTWARE\BlueStacks_nxt]"LogDir"="C:\\ProgramData\\BlueStacks_nxt\\Logs\\""DataDir"="C:\\ProgramData\\BlueStacks_nxt\\Engine\\""InstallDir"="C:\\Program Files\\BlueStacks_nxt\\""UserDefinedDir"="C:\\ProgramData\\BlueStacks_nxt""""fromreggisearchimportsearch_valuesdi=search_values(mainkeys=r"HKEY_LOCAL_MACHINE\SOFTWARE\BlueStacks_nxt",subkeys=("DataDir","InstallDir"))print(di){'HKEY_LOCAL_MACHINE\\SOFTWARE\\BlueStacks_nxt':{'DataDir':'C:\\ProgramData\\BlueStacks_nxt\\Engine\\','InstallDir':'C:\\Program Files\\BlueStacks_nxt\\'}}
Package: reggol
Reggol is your weird best friend when it comes to logging.UsageIt takes away some arguments frome your command line args; namely--logleveland--logpath.You may usereggol.help_string()to append reggols
argument help to your own command line.Usereggol.get_logger()in any of your code files for some powerful,
beautiful synced console-file logging. Woah!What else to sayHappy logging!
Package: reggy
reggyPython package for regularized regressions.Supported regularization terms:RidgeLASSONetwork-fusion penalty (https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6030897/)Installation$pipinstallreggyUsageA simple example with LASSO regularization:importreggyimportnumpyasnpalpha=0.3beta=1.7X=np.random.normal(size=(100,1))y=np.random.normal(X*beta+alpha,size=(100,1))model=reggy.RegReg(X,y,family=reggy.gaussian_family,regularizers=[(0.5,reggy.lasso)])model.fit()print(model.intercept_,model.coef_)## [[0.22491232]] [[0.9219889]]
Package: reghub-pack
RegHub Competitor News Analysis (Banking Sector)OverviewWe are data science master students at Frankfurt School of Finance and Management. For this project we teamed up with RegHub (https://www.reghub.io) to investigate how public news about competitors in the german banking space can be analysed on an ongoing basis. We worked with a dataset of 14609 news articles to train and test our approaches.Descripton of folders1_Exploratoy_Data_AnalysisGeneral exploration of the dataset and various visualizations.2_Data_PreprocessingRule-based labelling of the news articles into one or more of the following categories:legalsanctionspapersreportsstatementsguidelinespresspersonnelmarket3_ModellingTesting various supervised deep learning algorithms, using the rule-based labels for training and testing. We settled on BERT as our primary model for categorization.
Next to categorization we also include a short summary of the relevant events within the category. To generate this summary, Llama2 was used.
Alongside as part of information retrieval from the news articles we also used name entity recognision models to extract the name entities.
Also a similarity analysis was performed by training BERT-MLM, which can be used to filter out duplicate news articles.4_Weekly_PipelineScript that runs through the whole process of categorization and llama2 summary creation for a given dataset. Can be run at specified intervals to cover new news articles.5_MiscCollection of scripts that where used and or tested in the course of this project, but don't belong into the final main folders.reghub_packThis folder is used to package the models, to be able to release them as a pip package later on.UsageThe run file in the weekly analysis folder can be used to analyse the additional news articles of every week. It runs through the whole pipeline of BERT categorization and Llama2 summarization.Examples and resultsSee the presentation of this project:https://1drv.ms/b/s!AsfpqRPTBA6DvH3pPeYWj7ub28lM?e=BIp20hInstructions to use reghub wrapper packageUsing PiPStep Ipip install reghub-packStep IIimport reghub_packIf the above method doesn't work, try using poetryStep IInstall dependent packages: (terminal)conda env create -n myenv -f reghub_packages.ymlStep IIClone repository branch: (terminal)git clone -b reghub_pack https://github.com/kirteshpatel98/RegHub_news_signal_analysisStep IIIChange directory to the clone repocd */RegHub_news_signal_analysisStep IVInstall poetrypip install poetryStep VBuild poetrypoetry buildStep VIAdd package to your environmentpip install .Step VIIImport package in pythonimport reghub_packAcknowledgmentWe would like to express our sincere gratitude toGerrit KnippschildandRegHubfor their invaluable assistance and support throughout the duration of our project. Their contribution in providing us with access to the dataset and offering expert guidance has been instrumental.
Package: regi0
Regi0Regi0 is a Python package with useful functions to complement and verify biological records. These functions are divided into two main modules (geographic and taxonomic) and rely on both user data and several web APIs (e.g.GNR, IUCN and Species+).InstallationRegi0 works with Python versions 3.7 through 3.9.Usingpip:pipinstallregi0Usingconda:condainstall-cconda-forgeExecutionTo check whether the installation ofwiutilswas successful, execute the following command:python-c"import regi0"If this does not throw any error, the installation was successful.You can use anyregi0function by importing the package from a Python console or script. You can also execute flexible and predefined geographic and taxonomic verification workflows usingregi0's command line interface (CLI). For more information about the available functions and the CLI, check thedocumentation.How to contributeIt is recommended to install the package using avirtual environmentto avoid tampering other Python installations in your system.Clone this repo in your computer:gitclonehttps://github.com/PEM-Humboldt/regi0.gitGo to the project's root:cdregi0Install the package in development mode:pipinstall--editable.[dev,docs,test]Consideringregi0has dependencies such asfionaandrasterio, which may require additional installation steps to the ones described above (see1and2), it is also recommended using acondavirtual environmentto install it and avoid having to manually install other dependencies.Go to the project's root and create thecondavirtual environment:condaenvcreate-fenvironment.ymlActivate thecondavirtual environment:condaactivateregi0-devInstall the package in development mode:pipinstall--editable.[dev,docs,test]Unit testsGo to the project's root and execute:pytest tests/Authors and contributorsErika Suarez-Valencia -erikasvHelena Olaya-Rodríguez -heleolayaMarcelo Villa-Piñeros -marcelovillaLicenseThis project is licensed under the MIT License - see theLICENSE.txtfile for details.
Package: regicide
RegicideA framework for playing the card game Regicide.RequirementsThe package requires python version 3.7+ and should be compatible with Linux, Windows and macOS.InstallationThe Regicide framework can be installed in python using pip.$pipinstallregicideUsageExampleThe following is an example of implementing an agent with custom behavior. In this example the agent will always choose to play the six of diamonds if available. Otherwise, it will choose randomly from the available actions.importrandomimportregicidefromregicideimportactions,card,playersclassCustomPlayer:"""A player that always plays the Six of Diamonds if possible.Otherwise it will choose a random action."""defplay(self,state):legal_actions=state.action_space()c=card.Card(card.CardSuit.Diamonds,card.CardValue.Six)special_action=actions.ActionPlay(c)ifspecial_actioninlegal_actions:returnspecial_actionelse:returnrandom.choice(legal_actions)players=[CustomPlayer(),CustomPlayer(),CustomPlayer()]game=regicide.RegicideGame(players,seed=1337)result=game.playout()print(result,game.reward())APIThe framework has three submodules: \cd{actions}, \cd{card} and \cd{players}. Each module contains python classes that can be instantiated and used in the framework.ActionsAvailable actions are:Play(card: Card)AnimalCombo(cards: List[Card])Combo(cards: List[Card])Yield()Discard(cards: List[Card])ChangePlayer(id: int)RefillHandCardsAvailable cards are:Card(suit: CardSuit, value: CardValue)CardSuitthat can be:Spades,Hearts,Diamonds,ClubsorNone.CardValuethat can beAce...Kingor the special valueJester.PlayersInputPlayer()that allows user input for taking actions.RandomPlayer(seed: int)MCTSPlayer(playouts: int, num_threads: int, uct_variation: int, use_heuristics: bool)CaveatsCurrently, the python package does not support code suggestions in IDE's, making it more difficult to work with the package. This is a result of the method used to generate the python bindings and has no implication on actual performance or correctness of the program.
Package: regime-switch-model
===============regime_switch_model===============regime_switch_model is a set of algorithms for learning and inferenceof the Regime-Switching Model.Important links===============* Official source code repo: https://github.com/Liuyi-Hu/regime_switch_modelDependencies============The required dependencies to use regime_switch_model are* Python >= 2.7* NumPy (tested to work with >=1.13.1)* SciPy (tested to work with >=0.19.0)* scikit-learn >= 0.18.1Installation============First make sure you have installed all the dependencies listed above. Then runthe following command::pip install -U --user regime_switch_modelReference============* Ma, Ying, Leonard MacLean, Kuan Xu, and Yonggan Zhao. "A portfolio optimization model with regime-switching risk factors for sector exchange traded funds." Pac J Optim 7, no. 2 (2011): 281-296.Credits============Part of the code are from Python package 'hmmlearn'. Their source code can be found here: https://github.com/hmmlearn/hmmlearn
Package: regina
The programReginais a powerful tool for studying low-dimensional
topology. It comes with a fullPythoninterface that lets one
interact with it programmatically without writing any C++ code. Our
goal here is to provide self-contained binaries (“wheels”) of Regina’s
Python package that can be installed in seconds from Python’sPyPIpackage repository usingpip.The current version is somewhat experimental and is based on a
pre-release version of Regina; it is offered for macOS (10.14 and
newer) and Linux, but not Windows. To try it out, do:python3 -m pip install --user --upgrade "regina>=7.0"
python3 -m regina.testOn older versions of Linux, e.g. Ubuntu 18.04, you may need to updatepipfirst via:python3 -m pip install --user --upgrade pip wheelFor more on using Regina in Python see themain docs.These binaries are produced and maintained by Marc Culler, Nathan
Dunfield, and Matthias Goerner, though of course 99.9% of the code and
credit is due to Ben Burton and the other authors of Regina
itself. This project evolved out of Goerner’ssageReginabut works both with and withoutSageMath. To install and test in
SageMath do the following in a terminal window:sage -pip install --user --upgrade "regina>=7.0"
sage -python -m regina.testOne can also do this frominsideSageMath (including from a
notebook) by:sage: %pip install --user "regina>=7.0"
sage: import regina.test; regina.test.runTests()Please report any technical problems via theissue trackeron theGitHub sitedevoted to this repackaging of Regina.Building from sourceIf the available binaries do not work for you, you can try building
from source.  You will need have the development versions of the
libraries gmp, zlib, and bzip2 installed:git clone https://github.com/3-manifolds/regina_wheel
cd regina_wheel
python3 setup.py package_assemble
python3 setup.py bdist_wheel
python3 -m pip install dist/regina*.whlThis can easily take an hour or more.LicenseCopyright Ben Burton, Ryan Budney, William Pettersson, Marc Culler,
Nathan M. Dunfield, Matthias Goerner, and others 1999-present. This
code is released under theGNU General Public License, version 2or
(at your option) any later version as published by the Free Software
Foundation.
Package: regina-normalizer
Runpip install regina-normalizerIn a python shell, run:import regina_normalizer.normalizerInput stringnormalizer.input_string({text_string}, {domain})Example:normalizer.input_string("Leikurinn fór 2-2 fyrir KR.", "sport")Leikurinn fór tvö tvö fyrir K R .Input filenormalizer.input_file({input_file}, {output_file}, "other")Example:normalizer.input_file("input.txt", "output.txt", "other")input.txt:Símanr er 888-3492, en hjá þér?
Þetta ætti að taka 2-3 klst.```

output.txt

```Þetta þarf að norma að minnsta kosti tvö x . Ég verð þriggja ára í sumar . Símanúmer er átta átta átta <sil> þrír fjórir níu tveir , en hjá þér ? Þetta ætti að taka tvö til þrjár klukkustundir .```
Package: regionanalysis
***************region_analysis***************Region_analysis is a package derived and extended from region_analysis.pl in diffReps package. It is a utility to annotate the genomic intervals like the peak list of ChIP-seq or other interval lists from the genomic research. Now it supports human (hg19), mouse (mm9, mm10), and rat (rn4). New genomes will be added. Any question or suggestion is welcome!Dependency:###########bedtools: https://code.google.com/p/bedtools/pybedtools: https://github.com/daler/pybedtools::If easy_install or pip is available, then:easy_install pybedtoolsor:pip isntall pybedtoolsUsage:######region\_analysis.py [options]Options:########-h, --help show this help message and exit-i INPUT\_FILE\_NAME, --input=INPUT\_FILE\_NAME::Input region file must assume the first 3 columns contain (chr, start, end)-d ANNO\_DB, --database=ANNO\_DB::Choose database: refseq(default) or ensembl-r, --rhead Whether the input file contains column header-g GENOME, --genome=GENOME::Choose genome: mm10(default), mm9, hg19, rn4-v, --version::Version of Region_Analysis packageOutput:#######*-.annotated: the one-to-one output list, only the annotation entry whose TSS is nearest to the inquiry interval kept.*-.full.annotated: all hit entries are kept.*-.full.annotated.json: the json format output of -.full.annotated.Features:#########*ProximalPromoter: +/- 250bp of TSS*Promoter1k: +/- 1kbp of TSS*Promoter3k: +/- 3kbp of TSS*Genebody: Anywhere between a gene's promoter and up to 1kbp downstream of the TES.*Genedeserts: Genomic regions that are depleted with genes and are at least 1Mbp long.*Pericentromere: Between the boundary of a centromere and the closest gene minus 10kbp of that gene's regulatory region.*Subtelomere: Similary defined as pericentromere.*OtherIntergenic: Any region that does not belong to the above categories.Testing with examples:######################region\_analysis.py -i example/test\_without\_header.bed -g mm10 -d ensemblregion\_analysis.py -i example/test\_with\_header.bed -g mm10 -d ensembl -r
Package: region-cache
region_cacheRegion-based caching for Python/Flask with RedisFree software: MIT licenseDocumentation:https://region-cache.readthedocs.io.FeaturesRegion based Flask caching with Redis.This module provides high-level nested, region-based caching with Redis. A region is a dot-separated
namespace where cache keys and values live. It is implemented as hashes in redis. Parent-child relationships
are implemented as sets. Timeouts use the EXPIRE command. All work is persisted in redis, and two regions with
the same name on two different processes or even different servers will share the same storage.Invalidation of caches is “active”, not “lazy”, so caches are purged immediately upon invalidation, to solve
the problem of one process knowing about a cache invalidation and the other not. Cache writes are aggressively
pipelined and transactional, so if two processes write to the same key at the same time, results will not be
inconsistent.The cache is written as a Flask extension, so you can use init_app with a valid flask app to initialize it.
Simply set the CACHE_REDIS_URL setting in the config.Examples:Using the region as a context manager treats everything in the context manager as a single transaction:with region('abc.xyz') as r:
    x in r  # test for presence
    r[x] = 100  # get or KeyError
    x = r[x]  # set
    del r[x]  # removeBind to blinker signals, so the cache is purged declaratively:region('abc.xyz').invalidate_on(
    blinker.signal('a'),
    blinker.signal('b'),
    blinker.signal('c'),
    blinker.signal('d'),
)Nest regions. If you invalidate the parent region, all the children will also be invalidated. This is recursive, so
sub-sub-sub regions will be correctly invalidated as well:region('abc').region('xyz')  # subregion
region('abc').invalidate()  # invalidate abc AND xyzThe default serializers is “pickle”, but you can supply any serializer that exposes a loads and dumps, and individual
regions can be configured differently. Children inherit the settings of their parents.Finally, timeouts are supported, and by default the timeout refreshes itself every time you write to the cache
See the region() function for more detail on how to configure it.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.3.7 (2021-12-13)Support Python 3.9+0.1.0 (2018-05-04)First release on PyPI.
Package: regionconnect
regionconnectIIT Human Brain Atlas regionconnect app.
Before using the regionconnect app, please register your data into the IIT space. SeeIIT atlas manualfor more details.Getting the most probabel connectionsFirst method: import regionconnect function.To update yourpipand create a virtual environment:python -m pip install --upgrade pip
python3 -m venv regionconnectTest
source regionconnectTest/bin/activate
python3 -m pip install regionconnectLaunch python console and runregionconnectpython
>>from regionconnect import regionconnect
>>regionconnect.regionconnect('path_to_ROI_mask','path_to_output_text_file')Second method: run the regionconnect.py script directly.python3 -m pip install numpy nibabel
git clone https://github.com/SheridanQ/regionconnect.git
cd regionconnect
python ./regionconnect/regionconnect.py path_to_ROI_mask path_to_output_text_fileExamplepython ./regionconnect/regionconnect.py ./test/roi4.nii.gz ./test/results_roi4.txtLinksTo know more details and other resources such as gray matter resources, diffusion tensor template and high angular resolution diffusion imaging template, please go to:MRIIT websitandNeuroimaging Tools & Resources Collaboratory(NITRC).ReferencesQi X., Zhang S., Arfanakis K. Enhancement and Evaluation of the White Matter Connectome of the IIT Human Brain Atlas. Proc. Int. Soc. for Magn. Reson. In Med. (ISMRM) 2019.LicenseFor non-commercial usage: IIT license (See LICENSE).For commercial usage: Please email to:mri@iit.edu
Package: region-grow
Region GrowCreates a polygon using a set of points from a region of interest by grouping pixels whose spectral reflectance is similar. The polygons are created using a satellite image in GeoTIFF format. In this project several algorithms are implemented to build this figure. Among them are: Selection by similarity threshold (%), Euclidean distance and selection by confidence interval. The generated polygon is exported in ESRI Shapefile format.InstallationYou can install this package from PyPi.pipinstallregion-growCreate a new polygonToday, we are going to calculate a polygon for a sugar cane crop located in Boyaca, Colombia. The input data is a set of points near to the crop and the main goal is to find the mininum polygon which covers all the crop area only using a little number of the given examples and a satellite image. The satellite image is a 3 band raster of a Sentinel 2A scene. The bands we use are: Band 11 (Short Wave Infrared - I), Band 8 (Near Infrared) and Band 2 (Blue). The cell resolution is 10m X 10m per pixel. For band 11 we made a resampling process using a bilinear transformation.The given points were taken at the sugar cane crop borders. Near to this crop we have other crops like yucca and corn and non crops areas like native forest. The blue area is the sugar cane area, manually delimited, we want to achieve. The pink area is the corn corp, the yellov the yucca crop and the orange area is the native forest. The green points are the points given and the red one is the first.Finally, let's execute the algorithm to calculate this polygon. In this time, we will use the similarity threshold. This algorithm only use the first given point and expands the region scanning the 8-neighbors of the pixel. The pixel is chosen only if the refrectancy is on the +- range of reflectancy of the given point. When the the aproximately area is given. The algorithm recalculates the polygon minimizing the differencerg.execute_with_area(points_path=points_path,raster_path=raster_path,shape_path=shape_path,classifier_tag="BD",)The result is:If you want more details see the notebook available inexamples/Best regardsGeovanny
Package: regionprops-to-df
regionprops_to_dfTakes list containing regionprops objects output by skimage.measure.regionprops,
returns Pandas DataFrame of all non-dunder, non-hidden scalar and tuple attributes.#regionprops_to_df_testing
Creates a RegionProps object from a skimage.data stock photo, median filtered.
The RegionProps object is then converted to a Pandas DataFrame with regionprops_to_df.
The functions in the testing script create arrays from the RegionProps object and compares them to
the Pandas DataFrame arrays.
Package: regions
Regions is anAstropypackage for region handling.Please see theonline documentationforinstallation
instructionsand usage information.Citing RegionsIf you use Regions for a project that leads to a publication, whether
directly or as a dependency of another package, please include the
following acknowledgment:This research made use of Regions, an Astropy package for region
handling (Bradley et al. 202X).where (Bradley et al. 202X) is a citation to theZenodo
recordof the
Regions version that was used. We also encourage citations in
the main text wherever appropriate. Please see theCITATIONfile for details and an example BibTeX entry.LicenseRegions is licensed under a BSD 3-clause license.  Please see theLICENSEfile
for details.