Saravanan666/pypi-org huggingface dataset:
Package: mgv
Mangrove is a simple tool to help you to manage your projects.
It’s has been thought to be used by every one, from scholar teams to private companies, with or without any technical skills.
With a clean and intuitive interface, users create, open, connect or version data easily
without any knowledge of the nomenclatures and the data structure.
Based on a nodal interface, you plug pre-scripted nodes by your own TDs or the community to create and manage your files.
Originaly created for 3d post production ease, it’s widely open and can be used for a non limited type of projects.
Package: mgzip
mgzipA multi-threading implement of Python gzip moduleUsing a block indexed GZIP file format to enable compress and decompress in parallel. This implement use 'FEXTRA' to record the index of compressed member, which is defined in offical GZIP file format specification version 4.3, so it is fully compatible with normal GZIP implement.This module is~25Xfaster for compression and~7Xfaster for decompression (limited by IO and Python implementation) with a24 CPUscomputer.In theoretical, compression and decompression acceleration should be linear according to the CPU cores. In fact, the performance is limited by IO and program language implementation.UsageUse same method as gzip moduleimportmgzips="a big string..."## Use 8 threads to compress.## None or 0 means using all CPUs (default)## Compression block size is set to 200MBwithmgzip.open("test.txt.gz","wt",thread=8,blocksize=2*10**8)asfw:fw.write(s)withmgzip.open("test.txt.gz","rt",thread=8)asfr:assertfr.read(len(s))==sPerformanceCompression:Decompression:Brenchmarked on a 24 cores, 48 threads server (Xeon(R) CPU E5-2650 v4 @ 2.20GHz) with 8.0GB FASTQ text file.Using parameters thread=42 and blocksize=200000000WarningThis package only replace the 'GzipFile' class and 'open', 'compress', 'decompress' functions of standard gzip module. It is not well tested for other class and function.As the first release version, some features are not yet supported, such as seek() and tell(). Any contribution or improvement is appreciated.
Package: mgzip2
mgzipA multi-threading implement of Python gzip moduleUsing a block indexed GZIP file format to enable compress and decompress in parallel. This implement use 'FEXTRA' to record the index of compressed member, which is defined in offical GZIP file format specification version 4.3, so it is fully compatible with normal GZIP implement.This module is~25Xfaster for compression and~7Xfaster for decompression (limited by IO and Python implementation) with a24 CPUscomputer.In theoretical, compression and decompression acceleration should be linear according to the CPU cores. In fact, the performance is limited by IO and program language implementation.UsageUse same method as gzip moduleimportmgzips="a big string..."## Use 8 threads to compress.## None or 0 means using all CPUs (default)## Compression block size is set to 200MBwithmgzip.open("test.txt.gz","wt",thread=8,blocksize=2*10**8)asfw:fw.write(s)withmgzip.open("test.txt.gz","rt",thread=8)asfr:assertfr.read(len(s))==sPerformanceCompression:Decompression:Brenchmarked on a 24 cores, 48 threads server (Xeon(R) CPU E5-2650 v4 @ 2.20GHz) with 8.0GB FASTQ text file.Using parameters thread=42 and blocksize=200000000WarningThis package only replace the 'GzipFile' class and 'open', 'compress', 'decompress' functions of standard gzip module. It is not well tested for other class and function.As the first release version, some features are not yet supported, such as seek() and tell(). Any contribution or improvement is appreciated.
Package: mh
Example PackageTo showpackage distributionpackage testing (unit, performance, acceptance and multi interpreter)logging useloading to pypiUsageTo install, eitherpip install mhpip install git+https://github.com/MarkHallett/mh@v0.0.33To importimport mhExample usageprint mh.EG_VAR2print mh.test_function()print mh.Mh().run_mh()Further documentationmh docsTo run testsunitpython -m unittestperformancecd tests/performance; python test_perf.pyacceptancecd tests/acceptance; behave mh.featuremulti interpretertox
Package: mha_helper
MHA helper is a Python module that supplements in doing proper failover usingMHA.
MHA is responsible for executing the important failover steps such as finding the
most recent slave to failover to, applying differential logs, monitoring master for
failure, etc. But it does not deal with additional steps that need to be taken
before and after failover. These would include steps such as setting the read-only
flag, killing connections, moving writer virtual IP, etc.Required packages:PyMySQL
paramiko
Package: mhask
micropython-mhaskMicropython HTTP Asynchronous Service like FlaskInstallmicropython -m upip install micropython-mhaskUsageapp = mhask.App(__name__)

@app.route('/')
def index():
    return 'Hello'

app.run()See more examples athttps://github.com/damiencorpataux/micropython-mhask/blob/master/examples.
Package: mhcnames
All the fun and adventure of MHC nomenclature, now in PythonExampleIn[1]:mhcnames.parse_allele_name("HLA-A0201")Out[1]:AlleleName(species='HLA',gene='A',allele_family='02',allele_code='01')In[2]:mhcnames.compact_allele_name("HLA-A*02:01")Out[2]:'A0201'
Package: mhcnuggets
MHCnuggetsBranchTravis CI build statusmasterdeveloprichelWelcome to MHCnuggets! Presumably you're here to do some
peptide-MHC prediction and not because you werehungry.UsageFor an overview of how to use MHCnuggets please refer to the Jupyter notebook
calleduser_guide.ipynbin the repositoryIf you would like to use MHCnuggets as a docker container, there are several options:MHCnuggets with command line interfaceMHCnuggets with Jupyter Notebook interfaceMHCnuggets container for batch operationsInstallationMHCnuggets ispipinstallable as:pipinstallmhcnuggetsRequired pacakges:numpyscipyscikit-learnpandaskerastensorflowvarcodeYou might want to check if the Keras backend is configured to use
the Tensorflow backend.
Package: mhctools
mhctoolsPython interface to running command-line and web-based MHC binding predictors.Commandline examplesPrediction for user-supplied peptide sequencesmhctools--sequenceSIINFEKLSIINFEKLQ--mhc-predictornetmhc--mhc-allelesA0201Automatically extract peptides as subsequences of specified lengthmhctools--sequenceAAAQQQSIINFEKL--extract-subsequences--mhc-peptide-lengths8-10--mhc-predictormhcflurry--mhc-allelesA0201Python usagefrommhctoolsimportNetMHCpan# Run NetMHCpan for alleles HLA-A*01:01 and HLA-A*02:01predictor=NetMHCpan(alleles=["A*02:01","hla-a0101"])# scan the short proteins 1L2Y and 1L3Y for epitopesprotein_sequences={"1L2Y":"NLYIQWLKDGGPSSGRPPPS","1L3Y":"ECDTINCERYNGQVCGGPGRGLCFCGKCRCHPGFEGSACQA"}binding_predictions=predictor.predict_subsequences(protein_sequences,peptide_lengths=[9])# flatten binding predictions into a Pandas DataFramedf=binding_predictions.to_dataframe()# epitope collection is sorted by percentile rank# of binding predictionsforbinding_predictioninbinding_predictions:ifbinding_prediction.affinity<100:print("Strong binder:%s"%(binding_prediction,))APIThe following MHC binding predictors are available inmhctools:MHCflurry: open source predictor installed by default withmhctools, requires the user runmhcflurry-downloads fetchfirst to download MHCflurry modelsNetMHC3: requires locally installed version ofNetMHC 3.xNetMHC4: requires locally installed version ofNetMHC 4.xNetMHC: a wrapper function to automatically useNetMHC3orNetMHC4depending on what's installed.NetMHCpan: requires locally installed version ofNetMHCpanNetMHCIIpan: requires locally installed version ofNetMHCIIpanNetMHCcons: requires locally installed version ofNetMHCconsIedbMhcClass1: Uses IEDB's REST API for class I binding predictions.IedbMhcClass2: Uses IEDB's REST API for class II binding predictions.RandomBindingPredictor: Creates binding predictions with random IC50 and percentile rank values.Every binding predictor is constructed with anallelesargument specifying the HLA type for which to make predictions. Predictions are generated by calling thepredictmethod with a dictionary mapping sequence IDs or names to amino acid sequences.Additionally there is a module for running theNetChopproteosomal cleavage predictor:NetChop: requires locally installed version ofNetChop-3.1
Package: mhddq
mhddqModule implementing a multi-threaded hdd io queue.pip install mhddqimport mhddq
import time

# calls are enqueued instead of being called immediately
# 2 alternating io threads handle all io functions
# ideally while one thread is dealing with queue maintenance the
# other thread is using the hdd, and then they trade off when done
# after a function has been completed by the io threads its output
# is enqueued for a third thread to handle the callback as to not
# interfere with the two io threads
mhddq.file_exists(callback = cb_file_exists, filename = './file.txt')

def cb_file_exists(args):
    # args = {
    #     'action': str,  # function name, 'file_exists' in this case
    #     'result': bool, # if the function encoutered any errors then this is False
    #     'params': dict, # the params you initially passed, { 'callback': function, 'filename': str }
    #     'output': dict  # the output of the function, in this case { 'exists': bool }
    #                     # if result is False then this would be { 'exception': str }
    # }
    
    # print the result, 'file.txt exists: False'
    print(args['params']['filename'] + ' exists: ' + str(args['output']['exists']))
    
    # if a callback throws an exception it is caught and printed to stderr

# if multiple operations need to be grouped together you can use an oplist
fileops = mhddq.create_empty_oplist()

# oplists have their own sets of function calls
# in practice it ends up being the same as mhddq.file_exists()
# except the io thread considers the entire oplist as a single
# operation and won't yield to it's sister thread until the list
# has been completed
mhddq.oplist_file_exists(oplist = fileops, callback = cb_file_exists, filename = './file.txt')

# you can add an oplist directly to the io queue like this
mhddq.enqueue_oplist(fileops)

# or you can embed the oplist in another oplist
superlist = mhddq.create_empty_oplist()
mhddq.embed_oplist(superlist, fileops)

# embedded lists are processed as a single operation inside it's
# parent list, while it's parent list is processed as a single operation
# in the io queue
mhddq.enqueue_oplist(superlist)

# when it is time to turn off the app you can do a graceful shutdown
# this will prevent any new items from being enqueued and blocks the
# calling thread until the io and callback threads have cleared their
# queues and exited their processing loops
mhddq.shutdown()

# other threads can wait for a graceful shutdown by using a loop like this
while mhddq.is_shutdown() is False:
    time.sleep(0.01)

# once shutdown, mhddq can not be restarted without restarting the app
Package: mhealthdata
mHealthDataWearable health data to NumPyFeaturesRead health data export ofFitbit,Samsung Health, andApple HealthkitRead all.xml,.csv,.jsonto pandas DataframeFix time zone inconsistency and convert to local timeDevice-centric approach - output numpy arrays for selected wearable devicesResample to per-minute or per-day numpy arrays:(N days x 1440 minutes) forsteps,sleep, andbpm(N days) forweight,rhr, andhrvInstallationpip install mhealthdataQuick startAssume we haveFitbitdata export.zipdownloaded to folder/Users/username/Downloads/wearable_data/and unzipped into a subfolder/Users/username/Downloads/wearable_data/User/with lots of.xml,.csv,.jsonand sub-folders inside.Load data:import mhealthdata

path = '/Users/username/Downloads/wearable_data/User/'
wdata = mhealthdata.FitbitLoader(path)UseSHealthLoader()for loading Samsung Health exportUseHealthkitLoader()for loading Apple Health exportShow loaded dataframes aswell asstepsrecords dataframe:print(wdata.dataframes)
print(wdata.df['steps'].head())Data Analysis and VisualizationConvert data to numpy arrays:data = wdata.get_device_data()By defaultmhealthdatatruncatessteps/min,heart rate/, andweightin [kg] to physically meaningful range0 - 255.See valid device list:wdata.devicesGet numpy arrays for specific device e.g.data = wdata.get_device_data('iPhone')Date range:from datetime import datetime

idates = data['idate'] # ordinal days (January 1st of year 1 - is day 1)
dates = [datetime.fromordinal(d) for d in idates]
print(f'Date range {dates[0]} - {dates[-1]}')Plot one day of data:import pylab as plt

i = 9 # Let us plot day 10 (numbering starts with zero)
plt.figure(facecolor='white')
plt.title(f'Date {dates[i]}')
for dname in ['steps', 'sleep', 'bpm']:
    plt.plot(data[dname][i], label=dname)
plt.legend()
plt.show()Zero values indicate missing data (also not walking and not sleeping forstepsandsleep)By defaultmhealthdatapads data with zeros to match full weeks (Monday through Sunday), so some days at the beginning and at the end may be emptyData correlations:from scipy.stats import pearsonr

x = data['rhr']
y = data['weight']

# IMPORTANT: zero values indicate missing data and should be disregarded
mask = (x > 0) & (y > 0)
r, p = pearsonr(x[mask], y[mask])
print(f'Correlation {r:.2f}, P-value {p:.2g}')Missing data are a certaing problem in wearable data analysisA studyPyrkov T.V. et al., Nat Comms 12, 2765 (2021)shows high consistency of recovery rates in quite different biological signals - physical activity measured by consumer wearable devices and laboratory blood cell counts. The typical recovery time of 1-2 weeks. The finding suggests it may be safe to use averaging windows or impute data gaps of several day length (though both affect noise and correlation and therefore should be used with caution).Documentationhttps://mhealthdata.readthedocs.io
Package: mhealth-dataviz
Visualizing a year of data obtained from a smartwatch. Project for Northeastern MHealth Research group.version 0.6.0InstallationPython >= 3.7pip install mhealthlab-dataviz#Usage (CLI Application)Linux/Mac./main.py <path to processed data folder>####Windowspython main.py <path to processed data folder>OutputOutputs the year of data visualized as a .jpeg
Package: mh-en-exec
Machine Heads External NodesGetting StartedMachine Heads External Nodesis a python module for creating your own nodes for use onMachine Heads.
UsingExternal Nodesyou will be able to:Create your own nodesReceive data (including images) fromMachine HeadsnodesSend data (including images) toMachine HeadsnodesRun any python code onMachine Headstest sequenceInstallationUse the following command to installMachine Heads External Nodes:pip install mh_en_execMachine Heads External Nodesis now installed. Check out thequickstartto learn how to create a node and start theExternal Nodesserver.ExamplesThere is also a sample code in the "examples" folder.
To execute sample code, just install "mh_en_exec" and call the following command:python run.py
Package: mhi
MHImhi is a commandline style mailreader in the tradition of mh and nmh,
but mutated to support IMAP.Why?One thing that IMAP provides is the ability for multiple clients to
access the same mail store. Graphical clients are all well and good,
but sometimes a reversion to the commandline is necessary. Neither mh
nor nmh will talk to an IMAP server (mh's original semantics, which
nmh duplicates, rely on messages not auto-renumbering, as they do in
IMAP folders), so I had to write my own client.  Python's imaplib made this easy.How?As of v0.6.5 MHI is available as a PyPI package (pipx install mhi)
The same version also incorporates the old mkLinks wrapper-script functionality
via:python -m mhi.mklinks <destdir>.mhirc.mhirc is an ini-style config file (parsed with configobj).  Useful keys:connection- an imap[s]://[username[:password]]@host[:port]/path url string that
specifies how to connect to the imap serverconnection_passwd- the password to use when connection. To avoid putting the
password in plaintext in this file, if the string is surrounded by backticks
(`), it will be executed as a shell script whose stdout will be used as the
password.folder_prefix- the prefix to add to your IMAP folderscomp_template- the template put into your editor when you usecompto write new mailrepl_template- the template put into your editor when youreply to a messageTODO:use click - but would require new commands?more help - should be self-documentingLicensing information is in the LICENSE file. (short version: GPLv3 or CCBYSA)
Package: mhi-enerplot
Enerplot Automation LibraryThe Enerplot Automation Library is designed to allow control of the Enerplot
application from a Python script.RequirementsThe Enerplot Automation Library requires the following tools are installed:EnerplotPython 3.x (such as Python 3.7.1)Installation of these tools is beyond the scope of this README.InstallationFor the default version of Python 3:py -3 -m pip install  mhi.enerplotFor a specific version of Python, such as Python 3.7py -3.7  -m pip install  mhi.enerplotResourcesFor help, see:PSCAD Support ResourcesEnerplot Automation Library
Package: mhi-pscad
PSCAD Automation LibraryThe PSCAD Automation Library is designed to allow control of the PSCAD
application from a Python script.RequirementsThe PSCAD Automation Library requires the following tools are installed:PSCAD 5.xPython 3.x (such as Python 3.9.5)PIP - Python's package manager (included with Python 3.5 and later)PyWin32 - Python extensions for Microsoft WindowsResourcesFor help, see:PSCAD Support ResourcesMHI PSCAD Automation Library
Package: mhi-psout
PSOut ReaderA reader for the PSCAD *.psout fileExampleimportmhi.psoutimportmatplotlib.pyplotaspltwithmhi.psout.File('Cigre.psout')asfile:ac_voltage=file.call("Root/Main/AC Voltage/0")run=file.run(0)forcallinac_voltage.calls():trace=run.trace(call)time=trace.domainplt.plot(time.data,trace.data,label=trace['Description'])plt.xlabel(time['Unit'])plt.ylabel(trace['Unit'])plt.legend()plt.show()
Package: mhkit
MHKiT-Python is a Python package designed for marine renewable energy applications to assist in
data processing and visualization.  The software package includes functionality for:Data processingData visualizationData quality controlResource assessmentDevice performanceDevice loadsDocumentationMHKiT-Python documentation includes overview information, installation instructions, API documentation, and examples.
See theMHKiT documentationfor more information.InstallationMHKiT-Python requires Python (3.7, 3.8, or 3.9) along with several Python
package dependencies.  MHKiT-Python can be installed from PyPI using the commandpip install mhkit.
Seeinstallation instructionsfor more information.Copyright and licenseMHKiT-Python is copyright through the National Renewable Energy Laboratory,
Pacific Northwest National Laboratory, and Sandia National Laboratories.
The software is distributed under the Revised BSD License.
Seecopyright and licensefor more information.
Package: mhlabs-sentiment
sentimentdl_glove_imdb_enIn this introductory sample, we'll try to predict a sentiment (positive or negative) for customer reviews. In the world of machine learning, this type of prediction is known as binary classification.Sentiment Classification - of IMDb User Reviews - using LSTMAn end-to-end toolkit on building a movie review sentiment classification LSTM model in Keras Deep Learning with model h5 file. Model is trained on IMDb Movie reviewssource.As part of model training, we have trained LSTM nodels, with reasoning as to why LSTMs are well suited to handle (sequential) text data.Features ListModular project structurePython package setup configured, package available onpypiConnecting to MS SQL Databse bypyodbc, you can install latest MS SQL driver for python fromhereLogging and Exception handling to MS SQL byCalling Stored ProceduresMS SQLYou can find create table and stored Procedure scripts under "references" folderDownload DatasetsYou can download required datasets fromhereand keep it in "data/raw" folderPlan of ActionLoadIMDb Movie Reviews dataset (50,000 reviews)Pre-process datasetby removing special characters, numbers, etc. from user reviews + convertsentiment labelspositive & negative to numbers 1 & 0, respectivelyImport GloVe Word Embeddingto build Embedding Dictionary + Use this to build Embedding Matrix for our CorpusModel Training usingDeep Learning in Kerasfor:LSTM Modelsand analyse model performance and resultsLast, performpredictions on real IMDb movie reviewsSteps to run on WindowsPrerequisites:Python 3.9(ensure Python is added toPATH) +GitClientOpen GIT CMD >> navigate to working directory >> Clone this Github Repo (or download project files from GitHub directly)git clone https://github.com/MusaddiqueHussainLabs/sentimentdl_glove_imdb_en.gitOpen Windows Powershell >> navigate to new working directory (cloned repo folder)Run ProjectUsing Conda Environment:conda env create -f conda_env_win.yml   # create conda environment called 'app_env'
conda env list                          # check if app_env is created
conda activate app_env                  # activate app_env
python main.py                           # run the project
conda deactivate                        # close conda environment once doneUsing PIP + Virtualenv:pip install virtualenv                  # install virtual environment        
virtualenv ENV                          # create virtual environment by the name ENV
.\ENV\Scripts\activate                  # activate ENV
pip install -r .\pip_requirements.txt       # install project dependencies
python main.py                           # run the project
deactivate                              # close virtual environment once doneBug / Feature RequestIf you find a bug (the website couldn't handle the query and / or gave undesired results), kindly open an issuehereby including your search query and the expected result.References / ThanksBig thanks to below authors:Krish NaikData Science GaragecodebasicsSKILLCATE
Package: mhpp
IntroductionA median house price prediction (mhpp) project is dealt to demonstrate packaging.
This package helps to fetch, preprocess and split the data set into train and test and also
train models using Linear Regression, Decision Tree and Random Forest algorithms and also
evaluate them using MSE (Mean Squarred Error), RMSE (Root mean square error) and MAS (Mean
Absolute Error).InstallationCreate a virtual environment using conda before installation.conda env create -f deploy/conda/env.yamlUsing pippip install mhppFrom sourceClone the repo using git clone command.Note: Requires colab access as of now.git clone git@github.com:varun-mle/mle-training.gitExecute the below command.pip install .UsageFor fetching datafetch-datacommand is used.  Below command helps to know its usagefetch-data -hFor preprocessing and splitting the data into train & test datasetstrain-test-datais used. Below command helps to know its usage.train-test-data -hFor training the modeltraincommand is used. Below command helps to know its usagetrain -hFor evaluating the modelevaluatecommand is used. Below command helps to know its usageevaluate -hReferdocsfolder for the detailed documentation.
Package: mh-python
Language translator from MATLAB to PythonThis package provides a utilitymh_pythonto translate MATLAB into Python format while keeping most of the MATLAB accent.
The generated Python code hope to be directly runnable with themat2pyengine.Thismh_pythonutility was initially developed under fork ofMISS_HITand then exported to this seperated repository for uploading toPyPi.The development may still happen inside thefork. We hope to merge this utility
back tomiss_hitafter it is stable.UsageTry it onlinehere.# must installpython3-mpipinstall-Umh-python# recommend install for prettify generated codepython3-mpipinstallblackisort--upgrade# convert `.m` file to `.py` filemh_pythontests/mat2np/demo_fft.m--formatCopyright & LicenseThe initial intention ofmh_pythonwas to be an advanced analysis tool ofMISS_HIT,
so it is also licensed under the same GNU Affero GPL version 3 (or later) as described in LICENSE.AGPL.AcknowledgementsMISS_HITBlack