Saravanan666/pypi-org huggingface dataset:
Package: methcomp
Methcomp is a Python visualization library based and built onmatplotlib. It provides a high-level interface for method comparison for clinical chemisty methods, amongst others.
Here is some of the functionality that methcomp currently offers:
- Method comparison using Bland-Altman plots;
- Method comparison using regression techniques such as Passing-Bablok, Deming and simple linear regression;
- Method comparison for glucose sensors using Clarke and Parkes error grids.
Package: method-3mo-ahp
3MOAHPIntroductionThe multi-criteria technique analytic hierarchy process (AHP) has a significant drawback. If the pairwise comparison matrix (PCM) has inconsistent comparisons, in other words, a consistency ratio (CR) above the value of 0.1, the final solution cannot be validated. Many studies have been developed to treat the inconsistency problem, but few of them tried to satisfy different quality measures. The selected quality measures are: minimum inconsistency (fMI), the total number of adjusted pairwise comparisons (fNC), original rank preservation (fKT), minimum average weights adjustment (fWA) and finally, minimum L1 matrix norm between the original PCM and the adjusted PCM (fLM).Our approach is defined in four steps:The decision-maker should choose whichquality measuresshe/he wishes to use, ranging from one to all quality measures.The authors encode the PCM to be used in a many-objective optimization algorithm (MOOA), andeach pairwise comparison can be adjusted individually.The authors generate consistent solutions from the obtained Pareto optimal front that carry the desired quality measures in the third step.The decision-maker selects the most suitable solution for her/his problem. Remarkably, the decision-maker can choose one (mono-objective), two (multi-objective), three or more (many-objectives) quality measures.It's worth noting that our implementation can deal with AHP and Fuzzy AHP. The Fuzzy AHP needs a fuzzy triangular scale to work, and although the user can define his scale, we have implemented a default fuzzy triangular scale that can be used in most problems:Crisp NumberFuzzy Number1/9(1/9, 1/9, 1/9)1/8(1/9, 1/8, 1/7)1/7(1/8, 1/7, 1/6)1/6(1/7, 1/6, 1/5)1/5(1/6, 1/5, 1/4)1/4(1/5, 1/4, 1/3)1/3(1/4, 1/3, 1/2)1/2(1/3, 1/2,   1)1(  1,   1,   1)2(  1,   2,   3)3(  2,   3,   4)4(  3,   4,   5)5(  4,   5,   6)6(  5,   6,   7)7(  6,   7,   8)8(  7,   8,   9)9(  9,   9,   9)CitationFloriano, C.M., Pereira, V. and Rodrigues, B.e.S. (2022),3MO-AHP: An Inconsistency Reduction Approach through Mono-, Multi- or Many-objective Quality Measures,
Data Technologies and Applications, Vol. 56 No. 5, pp. 645-670.https://doi.org/10.1108/DTA-11-2021-0315UsageInstallpipinstallmethod_3mo_ahpTry it inColab:AHP:Example 01 - One Objective: (Colab Demo)Example 02 - Two Objectives: (Colab Demo)Example 03 - Three Objectives: (Colab Demo)Example 04 - Five Objectives: (Colab Demo)Fuzzy AHP:Example 05 - One Objective: (Colab Demo)Example 06 - Two Objectives: (Colab Demo)Example 07 - Three Objectives: (Colab Demo)Example 08 - Five Objectives: (Colab Demo)Example 09 - Custom Fuzzy Scale: (Colab Demo)OtherspyDecision- A library for many MCDA methodspyMissingAHP- A Method to Infer AHP Missing Pairwise ComparisonsELECTRE-Tree- Algorithm to infer the ELECTRE Tri-B method parametersRanking-Trees- Algorithm to infer the ELECTRE II, III, IV and PROMETHEE I, II, III, IV method parameters
Package: method-cache
Python Method CacheWhat it doesMethodCache can be used to cache the result of an method in a flexible way.
This libary has no dependencies!Currently only TTL Cache availableThe cache storage can be segmented in categories.
Methods with the@cachedecorator are saved in these categories.Examplefrommethodcacheimportcache,Storeimporttime# TTL in Seconds (Default TTl is 60)st=Store(ttl=60*300)# Define Store for this Cache, and overwrite Store TTL. And categorize this cache object to demo@cache(store=st,ttl=5,category="demo")defdoothings(a,b,c):# Do here what ever you want.# eg. MySQL querys or other slow operationstime.sleep(2)returna+b+c# Slow Executiondoothings(1,2,3)# Slow Executiondoothings(4,5,6)# Fast Execution because the Cache was useddoothings(1,2,3)time.sleep(2)# Slow Execution because the Cache TTL is Expireddoothings(1,2,3)DocumentationRead the Docsor
showexample.py
Package: methodic-cache
methodic_cachefunctools.cache()for methods, done correctly.methodic_cache.cached_methodis a decorator that caches the return value of a method, based on the arguments passed to it.The peculiarity of this library is that it does not store anything on objects themselves, but rather on a separate WeakKeyDictionary where the lifetime of the cache matches the lifetime of the object.An advantage of this approach over storing the cache on the object itself when needed is that objects will keep their memory footprint smaller thanks to shared key dictionaries. SeePEP 412andThe Dictionary Even Mightier - Brandon Rhodes at PyCon 2017, 00:21:02for more details.FeaturesSimple to useExtendable withcustom cache backends(e.g. LRUCache, LFUCache, etc.)Works with non-hashable objectsWorks withfrozen/slotted classesTested for memory leaksInstallationpipinstallmethodic_cacheUsagefrommethodic_cacheimportcached_methodclassMyClass:@cached_methoddefmy_method(self,arg1,arg2):returnarg1+arg2my_obj=MyClass()my_obj.my_method(1,2)# returns 3my_obj.my_method(1,2)# returns 3 from the cacheUsing classes with__slots__Classes that define__slots__need to have a__weakref__slot to be able to be weakly referenced:frommethodic_cacheimportcached_methodclassMyClass:__slots__=("my_attr","__weakref__")# <-- __weakref__ is requireddef__init__(self,my_attr):self.my_attr=my_attr@cached_methoddefmy_method(self,arg1,arg2):print(f"Computing{self.my_attr}+{arg1}+{arg2}...")returnself.my_attr+arg1+arg2my_obj=MyClass(1)my_obj.my_method(2,3)# prints "Computing 1 + 2 + 3..."# returns 6my_obj.my_method(2,3)# returns 6Custom cache backendsYou can use any cache backend that implements theMutableMappinginterface (e.g.dict,lru_cache,functools.lru_cache, etc.).
The default cache backend iscachetools.Cache(maxsize=math.inf), which will keep the cache bounded to the lifetime of theselfobject.You can use a different cache backend by passing it as thecache_factoryargument tocached_method:frommethodic_cacheimportcached_methodfromcachetoolsimportLRUCacheclassMyClass:@cached_method(cache_factory=lambda:LRUCache(maxsize=1))defmy_method(self,arg1,arg2):print(f"Computing{arg1}+{arg2}...")returnarg1+arg2my_obj=MyClass()my_obj.my_method(1,1)# prints Computing 1 + 1...# returns 2my_obj.my_method(1,1)# returns 2my_obj.my_method(2,2)# prints Computing 2 + 2...# returns 4my_obj.my_method(1,1)# <-- this will be recomputed because the cache is full# prints Computing 1 + 1...# returns 2
Package: method-of-moments
method_of_momentsmethod_of_momentsis a package that allows you to work with probability distributions with a specified mean values and variances.PrerequisitesBefore you begin, ensure you have installed the latest version of Python.Installingmethod_of_momentsTo installmethod_of_moments, follow these steps:Linux and macOS:pip3 install method-of-momentsWindows:pip install method-of-momentsUsingmethod_of_momentsThere are will be examples of how to usemethod_of_moments.Contributing tomethod_of_momentsTo contribute tomethod_of_moments, follow these steps:Fork this repository.Create a branch:git checkout -b <branch_name>.Make your changes and commit them:git commit -m '<commit_message>'Push to the original branch:git push origin <project_name>/<location>Create the pull request.Alternatively see the GitHub documentation oncreating a pull request.Contributors@AlbertFarkhutdinovContactIf you want to contact me you can reach me atalbertfarhutdinov@gmail.com.LicenseThis project uses the following license:MIT License.
Package: methodpickle
MethodPickle (methodpickle) is a quick library that allows simple pickling
and unpickling of function and method invocation.  Function & method module
loading is handled automatically, and methods can be specified by name as
well.The ability to pickle a method invocation allows for queueing and delayed
execution of arbitrary code.  This is useful for parallelization, logging,
queueing, etc.Contact:Steve Lacy <github@slacy.com>
Twitter: @sklacy
http://slacy.com/blogFeatures & UsagePlease see the unit tests in test.py for some more verbose examples, but
I’ll go through a quick example here.:from methodpickle.defer import defer

# These are the functions that we're going to defer
def some_function(x, y):
    return x*x + y*y

# methodpickle supports deferring execution of classmethods as well, so
# here's a simple class with a method:
def some_class(object):
    def __init__(self, x):
        self._x = x

    def calc(self, y):
        return (self._x * self._x + y * y)

if __name__ == '__main__':

    # the defer function takes a method and it's arguments, and turns it
    # into a pickleable object.
    storable_func = defer(some_function, 5, 4)

    # So, we pickle that guy into a string.
    method_str = pickle.dumps(storable_func)

    # You can now take method_str and do whatever you like with it.  Write
    # it to a database, send it to another process, put it in your logs,
    # whatever.

    # Then, you can unpickle the stored method invocation, and run it,
    # like this:
    recovered_func = pickle.loads()
    assert(recovered_func.run() == 5*5 + 4*4)

    # methodpickle also supports pickling of classmethods.  Note that your
    # class must support pickling and the methods should have no side
    # effects.

    i = some_class(2)
    storable_classmethod = defer(i, 3)

    classmethod_str = storable_method.dumps()
    recovered_classmethod = pickle.loads(classmethod_str)
    assert(recovered_classmethod.run() == 2*2 + 3*3)For convenience, there’s also a decorator form of the defer function, called
deferred.  Again, see the implementation or test.py for more details.CaveatsAll arguments to functions must themselves be pickle-able.Thisincludes ‘self’ for class method invocationsFunctions and classes must be at the module level.Inner classes andinner functions don’t have an easy-to-discover import path, so all the
deferred functions should be at the top level of your module.  I’d
suggest putting them all in the same file (say, tasks.py)All method arguments are deepcopied at the time of the deferral.Thus,if you pass a very large datastructure to the deferral methods, it may
have a performance impact.  In addition, if you pass a mutable
datastructur (dict, list, etc.) then subsequent modifications will have
no effect.Watch out for double invocation of functions & methods.  This is botha feature and a caveat.  Once you pickle a function call, that value
could be unpickled and run more than once.  Watch out for anything that
has unexpected side effects!
Package: methodtools
Expand functools features to methods, classmethods, staticmethods and even for
(unofficial) hybrid methods.For now, methodtools only providesmethodtools.lru_cache.Usemethodtoolsmodule instead offunctoolsmodule. Than it will work as
you expected.frommethodtoolsimportlru_cacheclassA(object):# cached method. the storage lifetime follows `self` object@lru_cache()defcached_method(self,args):...# cached classmethod. the storage lifetime follows `A` class@lru_cache()# the order is important!@classmethod# always lru_cache on top of classmethoddefcached_classmethod(self,args):...# cached staticmethod. the storage lifetime follows `A` class@lru_cache()# the order is important!@staticmethod# always lru_cache on top of staticmethoddefcached_staticmethod(self,args):...@lru_cache()# just same as functools.lru_cachedefcached_function():...InstallationPyPI is the recommended way.$pipinstallmethodtoolsTo browse versions and tarballs, visit:https://pypi.python.org/pypi/methodtools/NoteIf you are working on Python 2, install alsofunctools32.See also[Documentation](https://methodtools.readthedocs.io/en/latest/)This project is derived fromRing,
a rich cache interface using the same method handling technique.To learn more about bound method dispatching, see also
[wirerope](https://github.com/youknowone/wirerope).
Package: methpype
OverviewThis meta package will install the python packages that together make up themethylsuite:methylprepis a python package for processing DNA methylation data from Illumina arrays. It provides:A variety of background subtraction and normalization methods found in similar R-based packages.Support for Illumina arrays (27k, 450k, EPIC, mouse).Support for analyzing public data sets from GEO (the NIH Gene Expression Omnibus is a database) .Support for managing data inPandasDataFrames.methylcheckincludes:quality control (QC) functions for filtering out unreliable probes, based on the published literature,  sample outlier detection, plots similar to Genome Studio functions, sex prediction, and
and interactive method for assigning samples to groups, based on array data, in a Jupyter notebook.methylizeprovides these analysis functions:differentially methylated probe statistics (between treatment and control samples).volcano plots (which probes are the most different).manhattan plot (where in genome are the differences).Parts ofmethylsuiteData ProcessingQuality ControlInstallationThis all-in-one command will install all three packages and their required dependencies.pip3installmethylsuiteThis command was tested in a naive minimal conda environment, created thusly:condacreate-ntestsuiteAfterwards, I had to installstatsmodelsusing conda apart from the other dependencies, like so:condainstallstatsmodelspip3installmethylsuite(Statsmodels uses additional C-compilers during installation)
Package: methrandir
MehtrandirInstallationThis package is available onanacondaand can be installer with the following commandcondainstall-cskanderpoitmethrandirUsageDirectly from the command line:usage:methrandir.py[-h]-fFILES[-oOUT_PREFIX][-outdirOUTDIR][-mMETHOD][-cMIN_COVERAGE][-CCONTEXTS[CONTEXTS...]][-FFORCE][-pP_VALUE]MethylationDataOverviewUtility

optionalarguments:-h,--helpshowthishelpmessageandexit-fFILES,--filesFILEStabseperatedfilecontainingpathsofsortedbismarkCXreportsandtheir-oOUT_PREFIX,--out_prefixOUT_PREFIXoutputfilesprefix-outdirOUTDIR,--outdirOUTDIRoutputdirectory-mMETHOD,--methodMETHODmodelbiologicalreplicates:weighted_average|anova-cMIN_COVERAGE,--min_coverageMIN_COVERAGEminimumnumberofreadsforeachpositiononallsamples-CCONTEXTS[CONTEXTS...],--contextsCONTEXTS[CONTEXTS...]listofcontextstobeconsideredfordownstreamanalysis:CG,CHG,CHH-FFORCE,--forceFORCEForcerecreationoffilteredfiles-pP_VALUE,--p_valueP_VALUEp_valueforstatisticaltestsOr imported as a module in your python scrifrommethrandirimportmethrandirmethrandir.readlines() needs a.tsvfile describing raw data(Sorted Bismark CX reports) and can take other arguments to further filter data for each position.methrandir.compute_pca() takes in the product of readfiles and applies pca and generates some graphs.
Package: methylink
methylinkA command line tool to link methylated sites between two BAM/SAM files of the same origin.InstallationIn aclean:sparkles: environmentpipinstallmethylinkNOTE: This does not work on windows. Separately, C libraries like zlib may be a dependency if you do not already have htslib installed- peep here:https://pysam.readthedocs.io/en/latest/installation.html#requirements. If a faster solution is desired and docker is installed, please build the image to circumvent local dependencies. Thanks!Usage:Usage:methylink[OPTIONS]COMMAND[ARGS]...AcommandlinetooltolinkmethylatedsitesbetweentwoBAMfilesofthesameorigin.

Options:-h,--helpShowthismessageandexit.--versionShowtheversionandexit.--log_level[DEBUG|INFO|WARNING|ERROR|CRITICAL]Settheleveloflogoutput.[default:INFO]--threadsINTEGERNumberofthreadstouse.[default:1]--tmpPATHTempdirectorytouse.--methyl_bamsTEXTUnmappedbamfileswithmethylationtags.[required]--alnTEXTAlignedbamtomapthemethtagsto.[required]--sampleTEXTSamplename.Thiswillbeaprefixfortheoutput;e.g.CHM1-linked.bam[required]--outputTEXTOutputfile.[required]Quick startmethylink\--threads2\--alntests/data/CHM1_aln_test-subsampled.bam\--sampleCHM1\--methyl_bams"$(echotests/data/CHM1_methylated_test-{1,2,3,4,5}.bam)"\--outputCHM1-linked.bamDevelopmentI'm happy with any contributions to make this code better :muscle:. You should be able to go forth with the following:gitclone[thisrepo]cdmethylink
python-mvenvvmethsourcevmeth/bin/activate

pipinstall--editable.What remains to do-add to biocondaexpand on documentationuse signal library to catch for forced exit (eg. ctrl+c) to safely delete temp folderswrite github actions to automate test + build + publishTestpytestIf that's okay then you're good to go, :tada:!
Package: methylsuite
OverviewThis meta package will install the python packages that together make up themethylsuite:methylprepis a python package for processing DNA methylation data from Illumina arrays or downloading GEO datasets from NIH. It provides:Support for Illumina arrays (27k, 450k, EPIC, mouse).Support for analyzing public data sets from GEO (the NIH Gene Expression Omnibus is a database).Support for managing data inPandasDataFrames.data cleaning functions during processing, including:infer type-I channel switchNOOBpoobah (p-value with out-of-band array hybridization, for filtering lose signal-to-noise probes)qualityMask (to exclude historically less reliable probes)nonlinear dye bias correction (AKA signal quantile normalization between red/green channels across a sample)calculate beta-value, m-value, or copy-number matrixlarge batch memory management, by splitting it up into smaller batches during processingmethylcheckincludes:quality control (QC) functions for filtering out unreliable probes, based on the published literature,  sample outlier detection, plots similar to Genome Studio functions, sex prediction, and
and interactive method for assigning samples to groups, based on array data, in a Jupyter notebook.methylizeprovides these analysis functions:differentially methylated probe statistics (between treatment and control samples).volcano plots (which probes are the most different).manhattan plot (where in genome are the differences).Parts ofmethylsuiteData ProcessingQuality ControlInstallationThis all-in-one command will install all three packages and their required dependencies.pip3installmethylsuiteThis command was tested in a naive minimal conda environment, created thusly:condacreate-ntestsuiteAfterwards, I had to installstatsmodelsusing conda apart from the other dependencies, like so:condainstallstatsmodelspip3installmethylsuite(Statsmodels uses additional C-compilers during installation)
Package: metia
MetiaA tool (and a wrapper ofFFmpeg) to manipulate metadata of audio
files.This library is developed under Python 3.8.Installationpipinstall-UmetiaDependencyFFmpegUsageAll of the functionalities requires a ffmpeg/ffprobe build that has the
corresponding codec that the media is using. To set a custom build offfmpeg/ffprobe, set the variablesmetia.probe.FFPROBE_COMMANDand/ormetia.writter.FFMPEG_COMMAND.metia.ProbeIf all you want to do is to read the metadata, use this class. This provides a
wrapper offfprobeto extract commonly-used media metadata, such as bit-rate
and codec.Some methods of this class may be helpful to video files too.metia.MediaWORK IN PROGRESSThis class, apart from reading the metadata, allows you to alter the metadata,
including changing the tags of the media file and adding a cover art to it.This class, unlikemetia.probe.Probe, is highly targeted to music files (with
or without cover art). Although it is possible to integrate some video-related
features, the demands might differ so much that it's unworthy compared to using
the originalffmpegcommands. Thus, I believe a better way to utilize this
library with videos is to usemetia.probe.Probeto extract the information you
want and useos.system(or other equivalent) to invoke affmpegcommand.
Alternatively, you may look for other more powerful ffmpeg wrappers that has
support for more ffmpeg features, but that is beyond the scope of this project.Command Line InterfaceThis tool provides command-line interface for convenience.metia-probe: print the media info in a nicer (less messy) formatDevelopmentThis library is hosted on thisGithub repository. Visit to fork or
create issue/PR.
Package: meticulous
meticulousAutomate process of forking and running pyspelling on a repository to locate typos.More details can be found in theOnline Documentation.InstallationYou can install meticulous forPythonviapipfromPyPI.$ pip install meticulousPrerequisites:PyGithubplumbumspellingPyInquirerrequestsDownload from PyPI.orghttps://pypi.org/project/meticulous/ContributingContributions are very welcome, consider using thefile an issueto discuss the work before beginning, but if you already have a Pull Request
ready then this is no problem, please submit it and it will be very gratefully
considered. TheContribution Guidelinesoutlines the meticulous commitment to ensuring all
contributions receive appropriate recognition.LicenseDistributed under the terms of theGPLv3license, "meticulous" is free and open source softwareIssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.Additional Documentation:Online DocumentationNews.Template Updates.Code of Conduct.Contribution Guidelines.
Package: metinanaliz
Metin Analiz ProgramıVerilen metin dosyasında geçen cümleleri, kelimeleri ve heceleri analiz ederek YOD değerini bulur.YOD FormülüOKS= Toplam Kelime Sayısı / Toplam Cümle SayısıH3= 3 Heceli Kelime Sayısı / Toplam Cümle SayısıH4= 4 Heceli Kelime Sayısı / Toplam Cümle SayısıH5= 5 Heceli Kelime Sayısı / Toplam Cümle SayısıH6= 6 Heceli Kelime Sayısı / Toplam Cümle SayısıYOD=math.sqrt(OKS*((H3*0.84)+(H4*1.5)+(H5*3.5)+(H6*26.25)))Kullanımanaliz.py ornekler/metin1.txt > sonuclar/metin1.txt
Package: metintos
METeorological INterpolation Toolbox for Optimization and Simulation (METINTOS)What is METINTOS?METINTOS is a libray that interpolates meteorological variables in time.
It is distributed under the GNU Lesser General Public License v3.0.Citation info: D. Daniel González-Arribas, J. García-Heras, M. Soler and E.A. Enderiz, METeorological Interpolation Toolbox for Optimization and Simulation (METINTOS) an open source meteorological variable interpolator.How to run the libraryClone or download the repository.Install all the dependencies.How to use itFrom your meteorological files you have to create the dataset, you have to use xarray.open_mfdataset, you can obtain information in the xarray documentation (xarray.open_mfdataset link).ds=xr.open_mfdataset(files,engine='h5netcdf',concat_dim=['step'],combine='nested')Create the DatasetHandler calling metintos.io.DatasetHandler.dsh=metintos.io.DatasetHandler(cls.ds)Create CoordinateGenerator object and new axis, i.e.: latitudes, longitudes, steps.cg=metintos.io.CoordinateGenerator()cg.add_axis_lims_n_points('latitude',l0,lf,ls)cg.add_axis_lims_n_points('longitude',lo0,lof,los)cg.add_axis_lims_resolution('step',s0,sf,ss)Produce the new dataset interpolated with optical flowdsn=dsh.get_optical_flow_interpolated_dataset(cg.axes)How to compile documentation pdfYou can use the Makefile created by Sphinx to create your documentation. Locate yourself in the documentation path.First clean the _build directory to avoid error or legacy information. Just call:makecleanIn case you want to build your documentation in latex calltwice:makelatexpdfif you want to do build your in html call:makehtmlNote that youshould not seeany error or warning, this information appears as red text in the terminal.ContentsCheck METINTOS documentation in the following link:METINTOS documentation link.AcknowledmgementsThis library has been developed withinFMP-Met Project.FMP-Met has received funding from the SESAR Joint Undertaking (JU) under grant agreement No 885919. The JU receives support from the European Union’s Horizon 2020 research and innovation programme and the SESAR JU members other than the Union.