Saravanan666/pypi-org huggingface dataset:
Package: pymorpheus
Morpheus Python ModuleInstallationpip install pymorpheusUsageMorpheusClient() will either retrieve a token (with username and password args), or use an existing token (with token arg)
Usesslverify=Falseto bypass certificate validation.MorpheusClient.call() accepts the following vars:Required (positional):method: one of string: get, post, put, deletepath: api call path after /api/Optional:options: list of tuples eg.[('max','50')]jsonpayload: JSON string of payload for POST/PUT methodsReference athttps://bertramdev.github.io/morpheus-apidocmorpheus = MorpheusClient("https://yoururl", username="youruser", password="yourpass")
results = morpheus.call("get", path="instances")
print(results)
# JSON Output of results
Package: pymorphy2
Morphological analyzer (POS tagger + inflection engine)
for Russian and Ukrainian languages. License is MIT.docs:https://pymorphy2.readthedocs.iochangelog:https://github.com/kmike/pymorphy2/blob/master/CHANGES.rstsource code:githubbug tracker:https://github.com/kmike/pymorphy2/issuessupport:https://groups.google.com/forum/?fromgroups#!forum/pymorphyCitingKorobov M.: Morphological Analyzer and Generator for Russian and
Ukrainian Languages // Analysis of Images, Social Networks and Texts,
pp 320-332 (2015).Links:SpringerPDFBibTeX:@incollection{
   year={2015},
   isbn={978-3-319-26122-5},
   booktitle={Analysis of Images, Social Networks and Texts},
   volume={542},
   series={Communications in Computer and Information Science},
   editor={Khachay, Mikhail Yu. and Konstantinova, Natalia and Panchenko, Alexander and Ignatov, Dmitry I. and Labunets, Valeri G.},
   doi={10.1007/978-3-319-26123-2_31},
   title={Morphological Analyzer and Generator for Russian and Ukrainian Languages},
   url={http://dx.doi.org/10.1007/978-3-319-26123-2_31},
   publisher={Springer International Publishing},
   keywords={Morphological analyzer; Russian; Ukrainian; Morphological generator; Open source; OpenCorpora; LanguageTool; pymorphy2; pymorphy},
   author={Korobov, Mikhail},
   pages={320-332},
   language={English}
}
Package: pymorphy2-dicts
This is a package with pre-compiled OpenCorpora.org dictionary
data forpymorphy2.InstallationInstall:$ pip install pymorphy2-dictsRemove:$ pip uninstall pymorphy2-dictsUsageYou can get a path to the installed dataset usingpymorphy2_dicts.get_path()method. Usually you don’t have to do so,
because if all of the following apply:this package is installed;dictionary path is not passed topymorphy2.MorphAnalyzerconstructor;PYMORPHY2_DICTIONARY_PATHenvironment variable is not set,thenpymorphy2.MorphAnalyzer()uses dictionaries from this
package automatically.DevelopmentThe main repo ishttps://github.com/kmike/pymorphy2-dicts/. The repository
doesn’t contain the data itself: only package template and update
scripts are stored in VCS.There is a hg/bitbucket mirror athttps://bitbucket.org/kmike/pymorphy2-dicts/.License for Python code in this package is MIT. The data
is licensed underCreative Commons Attribution-Share Alike.
Package: pymorphy2-dicts-ru
Russian dictionaries forpymorphy2.InstallationInstall:$ pip install pymorphy2-dicts-ruUsageTo use these dictionaries with pymorphy2 create MorphAnalyzer
withlang='ru'parameter:>>> import pymorphy2
>>> morph = pymorphy2.MorphAnalyzer(lang='ru')To get a path to the installed dictionary data usepymorphy2_dicts_ru.get_path()method.DevelopmentThe main repo ishttps://github.com/kmike/pymorphy2-dicts/. The repository
doesn’t contain the data itself: only package template and update
scripts are stored in VCS.License for Python code in this package is MIT.
The data is licensed underCreative Commons Attribution-Share Alike.
Package: pymorphy2-dicts-uk
Ukrainian dictionaries forpymorphy2.InstallationInstall:$ pip install pymorphy2-dicts-ukUsageTo use these dictionaries with pymorphy2 create MorphAnalyzer
withlang='uk'parameter:>>> import pymorphy2
>>> morph = pymorphy2.MorphAnalyzer(lang='uk')To get a path to the installed dictionary data usepymorphy2_dicts_uk.get_path()method.DevelopmentThe main repo ishttps://github.com/kmike/pymorphy2-dicts/. The repository
doesn’t contain the data itself: only package template and update
scripts are stored in VCS.License for Python code in this package is MIT.
The data is licensed underCreative Commons Attribution-Share Alike.
Package: pymorphy3-dicts-ru
Russian dictionaries forpymorphy3.InstallationInstall:$ pip install pymorphy3-dicts-ruUsageTo use these dictionaries with pymorphy2 create MorphAnalyzer
withlang='ru'parameter:>>> import pymorphy3
>>> morph = pymorphy3.MorphAnalyzer(lang='ru')To get a path to the installed dictionary data usepymorphy3_dicts_ru.get_path()method.DevelopmentThe main repo ishttps://github.com/no-plagiarism/pymorphy3-dicts. The repository
doesn’t contain the data itself: only package template and update
scripts are stored in VCS.License for Python code in this package is MIT.
The data is licensed underCreative Commons Attribution-Share Alike.
Package: pymorphy3-dicts-uk
Ukrainian dictionaries forpymorphy3.InstallationInstall:$ pip install pymorphy3-dicts-ukUsageTo use these dictionaries with pymorphy2 create MorphAnalyzer
withlang='uk'parameter:>>> import pymorphy3
>>> morph = pymorphy3.MorphAnalyzer(lang='uk')To get a path to the installed dictionary data usepymorphy3_dicts_uk.get_path()method.DevelopmentThe main repo ishttps://github.com/no-plagiarism/pymorphy3-dicts. The repository
doesn’t contain the data itself: only package template and update
scripts are stored in VCS.License for Python code in this package is MIT.
The data is licensed underCreative Commons Attribution-Share Alike.
Package: pyMorseCode
pyMorseCode is a Python module with translates text to Morse code and Morse code back to text, following strictly the ITU Morse code alphabet.
The module holds one class names “MorseCode”, which holds all needed functions etc.
For a full documentation, read the docstrings of the class, as docstrings are complete:>>> from pymorsecode import MorseCode
>>> help(MorseCode)
Package: pyMorseTranslator
pyMorseTranslatorpyMorseTranslator provides tools for encoding and decoding strings in
morse code.  A typical usage scenario looks like this:#!/usr/bin/env python
from pyMorse import translator


# Initialize the encoder and decoder
encoder = translator.Encoder()
decoder = translator.Decoder()

# Encode the message
print(encoder.encode('This is morse code.').morse)

# Do stuff with the message

# Decode the message
print(decoder.decode(encoder.previousEncode.morse).plaintext)The output of this code would be:- .... .. ... / .. ... / -- --- .-. ... . / -.-. --- -.. . .-.-.-
THIS IS MORSE CODE.FeaturesCurrent FeaturesMorse encodingMorse decodingCustom symbols for dots, dashes and separatorsCustom characters for encoders and decodersPlanned FeaturesNone right now.ResourcesCurrently the only resource available is the files themselves, available athttps://github.com/Eagle-Eye2324/pyMorseTranslator
Package: py-mortgage
Py-MortgageTo install:pip install py_mortgageTo access Mortgage objectimport py_mortgage as pym
new_mortgage = pym.mortgage.Mortgage(rate=.04/12,term=360,loan=400000)py_mortgage has the following methods:Mortgage.get_pmt(): Will return the payment per periodMortgage.get_pmt(period): Will return all payments paid up to and including periodMortgage.get_amortization_table(format='pandas_df', decimal_places=2):
Will return an amortization table per period. If format = 'pandas_df', it will return a Pandas DataFrame. If format = 'json', it will convert the DataFrame to a JSON object. Decimal places defaults to 2.Mortgage.get_interest_pmt(period): Will return the total interest paid in periodMortgage.get_principal_pmt(period): Will return the total principal paid down in periodMortgage.cumulative_interest_pmt(period): Will return all interest paid up to and including period.Mortgage.cumulative_principal_pmt(period): Will return all principal paid up to and including period.Mortgage.remaining_mortgage_balance(ending_period): Will return the remaining principal up to and including ending_periodMortgage.describe(): Will return fields from MortgageMortgage.get_apr()is not completed yet and will be included in next release
Package: py-mortgagekit
# py-mortgagekit## Build Status[![Build Status](https://travis-ci.org/MikaSoftware/py-mortgagekit.svg?branch=master)](https://travis-ci.org/MikaSoftware/py-mortgagekit)[![PyPI version fury.io](https://badge.fury.io/py/py-mortgagekit.svg)](https://pypi.python.org/pypi/py-mortgagekit)[![Coverage Status](https://coveralls.io/repos/github/MikaSoftware/py-mortgagekit/badge.svg?branch=master)](https://coveralls.io/github/MikaSoftware/py-mortgagekit?branch=master)## DescriptionPython library for mortgage calculations.## Installation### Requirements* Python 3.6++### Instructions```bashpip instll py-mortgagekit```## Usage### DevelopmentHere is an example of using the using the library in your code.```pythonfrom mortgagekit.constants import *from mortgagekit.calculator import *# Define our variables.total_amount = Money(amount=250000.00, currency="USD")down_payment = Money(amount=50000.00, currency="USD")amortization_year = 25annual_interest_rate = Decimal(0.04)payment_frequency = MORTGAGEKIT_MONTH # see calculator.py for more options.compounding_period = MORTGAGEKIT_SEMI_ANNUALfirst_payment_date = '2008-01-01'# Feel free to use an alternate currency type by first checking to see if your# your currency is supported here:# https://github.com/limist/py-moneyed/blob/master/moneyed/localization.py#L348currency='USD'# Load up our calculator.calc = MortgageCalculator(total_amount, down_payment, amortization_year,annual_interest_rate, payment_frequency, compounding_period,first_payment_date, currency)# Perform computations.payment_schedule = calc.mortgage_payment_schedule()# You can now inspect the results and use it for your purposes.print(payment_schedule)```### Quality Assurance#### Unit TestsIf you want to run the unit tests, you can run the following.Here is how you run the unit tests.```bashpython setup.py test```#### Code CoverageHere is how you run code coverage. The first command runs the code coverageand the second command provides a report. If you would like to know more about ``coverage`` then click to [here to read](http://coverage.readthedocs.io/en/latest/).```bashcoverage run --source=mortgagekit setup.py testcoverage report -m```## LicenseThis library is licensed under the **BSD** license. See [LICENSE.md](LICENSE.md) for more information.
Package: pymorton
Ordinal hashing of multidimensonal data and geographic coordinates via Morton coding / Z-ordering.In mathematical analysis and computer science,Z-order,Morton-order, or aMorton-codeis a function
which maps multidimensional data to one dimension while preserving locality of the data points.
It was introduced in 1966 by IBM researcher, G. M. Morton. The z-value of a point in multidimensions is
calculated by interleaving the binary representations of its coordinate values. Once the data are sorted
into this ordering, any one-dimensional data structure can be used, such as binary search trees, B-trees,
skip lists, or hash tables. The resulting ordering can equivalently be described as the order one would
achieve from a depth-first traversal of a quadtree, where{x, y, …, K}are combined into a single
ordinal value that is easily compared, searched, and indexed against other Morton numbers.
Package: pyMosaic
Mosaic is a modular data model for molecular simulation applications.The Mosaic Python library provides an in-memory representation of
Mosaic data items plus input/output in HDF5 and XML formats. A
command-line tool provides conversion between the HDF5 and XML
representations as well as data import from the Protein Data Bank
(PDB).For the definition of the Mosaic data model, and a description
of the Python API, see the documentation in the directory ‘doc’.The Mosaic Python library requires Python 2.7 or Python 3.2 or 3.3
plus the following libraries:NumPy 1.6 or later (http://numpy.scipy.org/)HDF5 1.8.7 or later (http://www.hdfgroup.org/HDF5/)h5py 2.1 or later (http://www.h5py.org/)ImmutablePy 0.1 (http://bitbucket.org/khinsen/immutablepy/)Runnning the tests:python setup.py testInstallation:python setup.py install
Package: pymosaic-fits
# pymosaics[![PyPI version](https://badge.fury.io/py/pymosaic-fits.svg)](https://badge.fury.io/py/pymosaic-fits)
[![Build Status](https://travis-ci.org/volodymyrss/pymosaics.svg?branch=master)](https://travis-ci.org/volodymyrss/pymosaics)
[![codecov](https://codecov.io/gh/volodymyrss/pymosaics/branch/master/graph/badge.svg)](https://codecov.io/gh/volodymyrss/pymosaics)
[![Total alerts](https://img.shields.io/lgtm/alerts/g/volodymyrss/pymosaics.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/volodymyrss/pymosaics/alerts/)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/volodymyrss/pymosaics.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/volodymyrss/pymosaics/context:python)__CAUTION__:this is a simple functional project, although it should work as generally expected, do make sanity checks and make sure you understand what the mosaic does - as usual. In particular, the re-pixelization approach (mapping/interpolation) is suitable for maps with flux density, as long as the pixels are smaller than PSFMerge FITS file mosaicmaps all images in the same pixels (taken from one of the images, or healpix)sums with a flexible algorithmoutput mosaics format is compatible with input - allowing map-reduce operationsnote that pixelization used for mosaic and for the output is not necessarily the same, i.e. for healpix it’s useful to have “regular” projection output.clearly, healpix pixels are  useful primarily for all-sky.## Installation`bash $ pip installpymosaic-fits`## Example:`bash $ mosaictests/data/isgri_sky_ima_{1,2}.fits.gzout.fits # just a normal mosaic, pixels/output from first image $ mosaictests/data/isgri_sky_ima_{1,2}.fits.gzout.fits--mock# mock, to show assembly $ mosaictests/data/isgri_sky_ima_{1,2}.fits.gzout.fits--pixelshealpix # healpix pixels, projected output ``python import mosaicmosaic.mosaic_fn_list(["tests/data/isgri_sky_ima_1.fits.gz","tests/data/isgri_sky_ima_2.fits.gz"],"out.fits") `## Additional mosaic analysisUsinghttps://github.com/astromatic/sextractor/we provide some analysis, suitable for example for INTEGRAL ISGRI and JEMX mosaics:![image](https://user-images.githubusercontent.com/3909535/145425580-ee459651-dd81-448d-bc44-5af3462b5013.png)
Package: pymosaics
# pymosaicsMerge FITS file mosaicmaps all images in the same pixels (taken from one of the images, or healpix)sums with a flexible alhorithmoutput mosaics format is compatible with input - allowing map-reduce operations## Installation`bash $ pip install pymosaics `## Example:`bash $ mosaictests/data/isgri_sky_ima_{1,2}.fits.gzt.fits ``python import mosaic$mosaic.mosaic_fn_list(["tests/data/isgri_sky_ima_1.fits.gz","tests/data/isgri_sky_ima_2.fits.gz"],"out.fits") `
Package: pymosp
PyMOSPPyMOSP is a Python library to accessMOSP.InstallationUse it as a command line tool$pipxinstallpymosp
installedpackagepymosp0.5.2,Python3.12.1
Theseappsarenowgloballyavailable-pymospdone!✨🌟✨

$exportMOSP_URL_API=https://objects.monarc.lu/api/v2/
$exportTOKEN=<YOUR-TOKEN>

$pymospobject--list{'metadata':{'count':'5074','offset':'0','limit':'10'},'data':[{'id':144,'name':'Use of an obsolete version of the messaging server','description':'','schema_id':14,'org_id':4,'last_updated':'2021-03-16T12:45:35.046659','json_object':{'code':'1118','uuid':'69fc03a0-4591-11e9-9173-0800277f0571','label':'Use of an obsolete version of the messaging server','language':'EN','description':''},'organization':{'id':4,'name':'MONARC','description':'MONARC is a tool and a method allowing an optimised, precise and repeatable risk assessment.','organization_type':'Non-Profit','is_membership_restricted':True,'last_updated':'2018-05-18T09:50:57'},'licences':None},...,{'id':284,'name':'Tempting equipment (trading value, technology, strategic)','description':'','schema_id':14,'org_id':4,'last_updated':'2021-03-16T12:45:33.862787','json_object':{'code':'278','uuid':'69fc0ee2-4591-11e9-9173-0800277f0571','label':'Tempting equipment (trading value, technology, strategic)','language':'EN','description':''},'organization':{'id':4,'name':'MONARC','description':'MONARC is a tool and a method allowing an optimised, precise and repeatable risk assessment.','organization_type':'Non-Profit','is_membership_restricted':True,'last_updated':'2018-05-18T09:50:57'},'licences':None}]}Use it as a Python librarypipinstallpymospimportpymosp,osmosp=pymosp.PyMOSP(os.getenv("MOSP_URL_API"),os.getenv("TOKEN"))params={"organization":"MONARC","schema":"Library objects"}r=mosp.objects(params=params)print(r)or via the Git repository:$gitclonehttps://github.com/NC3-LU/PyMOSP
$cdPyMOSP
$poetryinstall
$poetryrunnose2-v--pretty-assertDocumentationAdocumentationis available on the MONARC website.ExamplesSee the examples in the fileexample.pyor in the tests folder.LicenseThis software is licensed underGNU General Public License version 3.Copyright (C) 2019-2024 Cédric BonhommeCopyright (C) 2019-2024 LHCFor more information,the list of authors and contributorsis available.
Package: pymoten
What is pymoten?pymotenis a python package that provides a convenient way to extract motion energy
features from video using a pyramid of spatio-temporal Gabor filters[1][2]. The filters
are created at multiple spatial and temporal frequencies, directions of motion,
x-y positions, and sizes. Each filter quadrature-pair is convolved with the
video and their activation energy is computed for each frame. These features
provide a good basis to model brain responses to natural movies[3][4].InstallationClone the repo from GitHub and do the usual python installgitclonehttps://github.com/gallantlab/pymoten.gitcdpymotensudopythonsetup.pyinstallOr with pip:pipinstallpymotenGetting startedExample using synthetic dataimportmotenimportnumpyasnp# Generate synthetic datanimages,vdim,hdim=(100,90,180)noise_movie=np.random.randn(nimages,vdim,hdim)# Create a pyramid of spatio-temporal gabor filterspyramid=moten.get_default_pyramid(vhsize=(vdim,hdim),fps=24)# Compute motion energy featuresmoten_features=pyramid.project_stimulus(noise_movie)Simple example using a video fileimportmoten# Stream and convert the RGB video into a sequence of luminance imagesvideo_file='http://anwarnunez.github.io/downloads/avsnr150s24fps_tiny.mp4'luminance_images=moten.io.video2luminance(video_file,nimages=100)# Create a pyramid of spatio-temporal gabor filtersnimages,vdim,hdim=luminance_images.shapepyramid=moten.get_default_pyramid(vhsize=(vdim,hdim),fps=24)# Compute motion energy featuresmoten_features=pyramid.project_stimulus(luminance_images)References[1]Adelson, E. H., & Bergen, J. R. (1985). Spatiotemporal energy models for the perception of motion.
Journal of the Optical Society of America A, 2(2), 284-299.[2]Watson, A. B., & Ahumada, A. J. (1985). Model of human visual-motion sensing.
Journal of the Optical Society of America A, 2(2), 322–342.[3]Nishimoto, S., & Gallant, J. L. (2011). A three-dimensional
spatiotemporal receptive field model explains responses of area MT neurons
to naturalistic movies. Journal of Neuroscience, 31(41), 14551-14564.[4]Nishimoto, S., Vu, A. T., Naselaris, T., Benjamini, Y., Yu, B., &
Gallant, J. L. (2011). Reconstructing visual experiences from brain activity
evoked by natural movies. Current Biology, 21(19), 1641-1646.A MATLAB implementation can be foundhere.
Package: pymoth
pymoth (Multi-Object Tracking Handler) is designed to
make information from MOTChallenge data set sequences easy to load and access in Python.
The pymoth object is a Namespace which stores a Sequence object for each set of labels in the data set.
Each sequence object contains of a number of Frames, each containing constituent Instance objects.
Instances can return information such as the bounding box, id number, and appearance patch.
Package: pymotifcounter
A unified Python interface to fast motif enumeration algorithms such as:mfinderfanmodNetMODEPGDA typical usage example is as follows:"""
Visualise the distribution of size-3 motifs.
"""frompymotifcounter.concretecountersimportPyMotifCounterMfinderfrommatplotlibimportpyplotaspltfromnetworkximportwatts_strogatz_graphif__name__=="__main__":# Create an example networkg=watts_strogatz_graph(100,8,0.2)# Create a motif counter based on mfindermotif_counter=PyMotifCounterMfinder()# Enumerate motifs using the selected counterg_mtf_count=motif_counter(g)# Visualise the distributiong_mtf_count.plot.bar("motif_id","nreal")plt.tight_layout()plt.show()Which would produce the following distribution:InstallationLatest release can be installed from pypi by> pip install pymotifcounter.Latest development version can be obtained bycloning this repositoryFor more details please seethe project’s documentation on readthedocs
Package: pyMOTO
pyMOTOLink to DocumentationLink to GitHubModular topology optimization framework with semi-automatic derivatives. The two main typesModuleandSignalare used to implement a problem formulation to be optimized. TheModuleimplements functionality (and design
sensitivity calculations) andSignalcarries data of both the variables and their derivatives.Sensitivity calculations are done based on backpropagation. The final value of interest is seeded with sensitivity
value $\frac{\textup{d}f}{\textup{d}f}=1$. Then the modules are executed in reverse order, each applying the chain rule.
As example for aModulewhich maps $x\rightarrow y$, only the following operation needs to be implemented:$$
\frac{\textup{d}f}{\textup{d}x} = \frac{\textup{d}f}{\textup{d}y}\frac{\textup{d}y}{\textup{d}x}\text{.}
$$In this way, the order of modules can easily be adapted without having to worry about sensitivities, as these are
automatically calculated.Quick start installationMake sure you have Python running in some kind of virtual environment (e.g.conda,miniconda,venv)Install the pymoto Python package (and its dependencies)Option A (conda): If you are working with Conda, install byconda install -c aatmdelissen pymotoOption B (pip): Typepip install pymotointo your console to installDownload one of the examples found in the repository's example folder
(here)Run the example by typingpython ex_....pyin the consoleA local installation for development inpyMOTOcan be done by first downloading the entire git repo, and then callingpip install -e .in thepyMOTOfolder (of course from within your virtual environment).DependenciesNumPy- Dense linear algebra and solversSciPy- Sparse linear algebra and solversSymPy- Symbolic differentiation forMathGeneralmoduleMatplotlib- Plotting and visualisation(optional)SAO- Sequential approximated optimizers(optional)opt_einsum- Optimized function forEinSummoduleFor fast linear solvers for sparse matrices:(optional)pypardiso- Uses the Intel OneAPI PARDISO solver (recommended)(optional)scikit-umfpack- Fast LU linear solver based on UMFPACK(optional)scikit-sparse- Fast Cholesky solver based on CHOLMOD(optional)cvxopt- Another fast Cholesky solver based on CHOLMODNote on linear solvers for sparse matrices:Scipy implements a version of LU which is quite slow. To increase the
speed of the optimization,pypardisois recommended as it contains a very robust and flexible solver for symmetric
and asymmetric matrices. An alternative isscikit-umfpackwhich provides a fast LU factorization. For symmetric
matrices a Cholesky factorization is recommended (not provided with Scipy), which can be used by either installingscikit-sparseorcvxopt.LicensepyMOTO is available under teMIT License.