Saravanan666/pypi-org huggingface dataset:
Package: merlin-dataloader
Merlin DataloaderThe merlin-dataloader lets you quickly train recommender models for TensorFlow, PyTorch and JAX. It eliminates the biggest bottleneck in training recommender models, by providing GPU optimized dataloaders that read data directly into the GPU, and then do a 0-copy transfer to TensorFlow and PyTorch usingdlpack.The benefits of the Merlin Dataloader include:Over 10x speedup over native framework dataloadersHandles larger than memory datasetsPer-epoch shufflingDistributed trainingInstallationMerlin-dataloader requires Python version 3.7+. Additionally, GPU support requires CUDA 11.0+.To install using Conda:conda install -c nvidia -c rapidsai -c numba -c conda-forge merlin-dataloader python=3.7 cudatoolkit=11.2To install from PyPi:pip install merlin-dataloaderThere are alsodocker containers on NGCwith the merlin-dataloader and dependencies included on themBasic Usage# Get a merlin dataset from a set of parquet filesimportmerlin.iodataset=merlin.io.Dataset(PARQUET_FILE_PATHS,engine="parquet")# Create a Tensorflow dataloader from the dataset, loading 65K items# per batchfrommerlin.dataloader.tensorflowimportLoaderloader=Loader(dataset,batch_size=65536)# Get a single batch of data. Inputs will be a dictionary of columnname# to TensorFlow tensorsinputs,target=next(loader)# Train a Keras model with the dataloadermodel=tf.keras.Model(...)model.fit(loader,epochs=5)
Package: merlin-py
Merlin-py is a tool that makes use of camelot ( /atlanhq/camelot ) and tabula ( /tabulapdf/tabula ) to furthur simplify the extraction of tabular data from PDFs. Merlin-py aims to simplify data extraction by providing a search logic to users of the package for data extraction, whether that be a table label, set of column names, or table dimensions. An ideal use case is for the extraction of a common data table across many hundreds, or thousands of separate pdfs where the desired data is in different locations on each document.. (Tax documents, historical records, etc)Big thanks to the developers and contributors of both tabula-py and camelot-py as this project is largely built atop these two other efforts.If you have or see an issues with merlin-py please email Kellen O'Connor atkellen.t.oconnor@gmail.comUpcoming updates:1 - Youtube / Video tutorial with accompanying jupyter notebooks.
2 - Additional OCRing module (in addition to existing tesseract) using sklearn.
Package: merlin-sdk
Merlin SDKThis project contains python library for interacting with Merlin, machine
learning model serving component of CaraML.
It provides interface to:Manage ML project resourcesTrack metrics and training performancePackage and Deploy ModelInstallationpipinstallmerlin-sdkand authenticate to gcloudgcloudauthapplication-defaultloginGetting StartedThe easiest way to get started is to explore example notebook:Deploying xgboost modelDeploying sklearn modelDeploying tensorflow modelDeploying pytorch modelDeploying user defined modelDevelopmentRequirements:pipenv (pip install pipenv)swagger code gen (brew install swagger-codegen)Setup development environment:makesetupMerlin CLIWith the CLI, users can deploy a trained model (serialized model) without touching Python code at all.To use the CLI:// to see available subcommands
merlin --help

// to see subcommand options
merlin SUBCOMMAND --help

// deploy existing xgboost model located inside cur_model_dir
merlin deploy --url localhost --model-type xgboost --project sample --model-dir cur_model_dir --model-name xgboost-sample --env staging

// undeploy xgboost-sample version 1
merlin undeploy --url localhost --project sample --model-name xgboost-sample --model-version=1

// generate pyfunc code base
merlin scaffold -p merlin-project -m model-name -e id
Package: merlin-sok
SparseOperationKit (SOK) is a python package wrapped GPU accelerated operations dedicated for sparse training / inference cases. It is designed to be compatible with common DeepLearning (DL) frameworks, for instance, TensorFlow. Most of the algorithm implementations in SOK are extracted from HugeCTR, which is a GPU-accelerated recommender framework designed to distribute training across multiple GPUs and nodes and estimate Click-Through Rates (CTRs). If you are looking for a very efficient solution for CTRs, please check HugeCTR.
Package: merlon
Merlon is a mod manager for the Paper Mario (N64) decompilation.DocumentationLegalThis application is licensed under the Mozilla Public License 2.0. See theLICENSEfile for details.Mods created with this application are not covered by this license. Mods packaged into a distributable with this
application are encrypted using the original game ROM, and cannot be used without the original game ROM.
No guarantees are made about the legal status of using this application to create mods.The author is not affiliated with Nintendo Co., Ltd. in any way.The PAPER MARIO trademark owned by Nintendo Co., Ltd. is used in this modding tool under the fair use doctrine, solely
for the purpose of enabling users to modify the game in a transformative manner.
Package: mermaidmro
mermaidmroCreate mermaid graphs from the method resolution order (mro) of Python objects.CLI ExamplesFor the examples below, let's consider the following classes saved in a filecode.pythat can be imported viaimport code(adjust yourPYTHONPATHif this is not the case).# code.pyclassA(object):passclassB(object):passclassC(A):passclassD(C,B):passGenerate mermaid textSimply pass the module and class in the formatmodule_name:class_nametomermaidmro.>mermaidmrocode:D

graphTDcode.D("code.D (0)")code.C("code.C (1)")code.A("code.A (2)")code.B("code.B (3)")object("object (4)")code.C-->code.Dcode.B-->code.Dcode.A-->code.Cobject-->code.Bobject-->code.AYou can hide the mro indices by adding--no-mro / -n.>mermaidmrocode:D--no-mro

graphTDcode.C-->code.Dcode.B-->code.Dcode.A-->code.Cobject-->code.Bobject-->code.AYou can also limit the maximum depth via--max-depth / -m.>mermaidmrocode:D--no-mro--max-depth1graphTDcode.A-->code.Dcode.B-->code.DOpen the graph in your browserJust configure the executable of your browser you like to open the graph with via--cmd / -c(on Macs this is usually justopen).
This functionality is based on themermaid.liveservice.>mermaidmrocode:D--cmdopen# opens https://mermaid.ink/img/pako:eNptkM8KwjAMh18l5JSBE_-dPAht9wgec6lbdYrdZNTT2LvbUUvLWE6_fB8kISPWfWPwDPgY9KeFa8Ud-JrptiLGEIB2BWORORWdAtovnIhOAB0WTkYngY7J9beXqZ13IQCdgss3Qlle_oflA9exSFjlKxKW61jgBtCawepnM_9lZHStsYZ9w9iYu_6-HeOE0w_Nr1i5?type=pngTo open the graph in the live editor, add--edit.Visualize the graph in your terminalThis requires that you have a tool installed that lets you visualize images in your terminal, e.g.imgcatforiTerm2.>mermaidmrocode:D--visualizeimgcat# showsDownload the graph>mermaidmrocode:D--downloadgraph.pngInstallationSimply install viapippipinstallmermaidmroDevelopmentSource hosted atGitHubReport issues, questions, feature requests onGitHub IssuesIf you like to contribute, I'm happy to receive pull requests.
Just make sure to add a new test cases and run linting and coverage checks:>./tests/test.sh
>./tests/lint.sh
>./tests/coverage.sh
Package: mermaid-py
Mermaid-pythis package works as an interface for the famous mermaid-js library that uses scripts to create diagrams.DescriptionBriefly describe your project here. Explain what it does and what makes it special.Examplesfirst installmermaid-pybypip install mermaid-py.importmermaidasmdfrommermaid.graphimportGraphgraph:Graph=Graph('first-graph',"""graph TD;mer(Mermaid)flow(FlowChart);clas(ClassDiagram)gra(Graph)erDigram(ERDiagram)erdiagram-link(Link)entity(Entity)flow-link(Link)node(Node)mer --> flowmer --> clasmer --> gramer --> erDigramflow --> node & flow-linkerDigram --> entity & erdiagram-link""")graphe:Mermaid=Mermaid(graph)graphe# !! note this work just in notbooke that render html.the result will be like thisgraph TD;
    mer(Mermaid)
    flow(FlowChart);
    clas(ClassDiagram)
    gra(Graph)
    erDigram(ERDiagram)
    pie(PieDiagram)
    reqDiagram(RequiremntDiagram)
    userj(UserJourney)
    erdiagram-link(Link)
    entity(Entity)
    flow-link(Link)
    node(Node)
    requiremnt(Requiremnt)
    element(Element)
    actor(Actor)
    section(Section)
    task(Task)
    mer --> flow & clas & gra & erDigram & pie & reqDiagram & userj
    flow --> node & flow-link
    erDigram --> entity & erdiagram-link
    reqDiagram --> requiremnt & element
    userj --> actor & section & taskTechnologies UsedPython3PoetryTo contribute tomermaid-pyIf you'd like to contribute to this open source project folow this steps:Forke the repo and then clone it.Navigate to the project directory:cd mermaid-py.create a local enviromentpython3 -m venv env.activate the envsource env/bin/activate.install the dependeciespoetry install.happy coding :) .List of DiagramesFlowChartSequence DiagramClass DiagramState DiagramEntity Relationship DiagramUser JourneyGanttPie ChartQuadrant ChartRequirement DiagramGitgraph (Git) Diagram 🔥C4 Diagram 🦺⚠️Mindmaps 🔥Timeline 🔥Zenuml 🔥Sankey 🔥XYChart 🔥LicenseThis project is licensed under theMIT License.ContactIf you have any questions or want to get in touch, you can reach out to me atrachidouhammou21@gmail.com.
Package: mermaid-python
mermaid-pythonYou can use this package to generate diagrams using Mermaid JS in a Jupyter notebook.To install, runpip install mermaid-python.You can generate a simple flowchart by running:frommermaidimportMermaidMermaid("graph TB\na-->b")You can also use themes:Mermaid("""%%{init: {'theme': 'base','themeVariables': {'primaryColor': '#BB2528','primaryTextColor': '#fff','primaryBorderColor': '#7C0000','lineColor': '#F8B229','secondaryColor': '#006100','tertiaryColor': '#fff'}}}%%graph LRA --- BB-->C[fa:fa-ban forbidden]B-->D(fa:fa-spinner);""")
Package: mern
mernmern is python library to help us process our dataset, it can process numeric and text dataInstallationpip3installmernorgitclonehttps://github.com/bluenet-analytica/mern.git&&cdmern&&pip3install-rrequirements.txt1. Remove outlier in numerical dataThere are 2 ways to remove data on numerical data typeZ ScoreInter Quartile Score Range (IQR Score)frommernimportNumericOutlierobj=NumericOutlier()x=[11,31,21,19,8,54,35,26,23,13,29,17]# using Z Scoreprint(obj.find(x,"zscore"))# using Inter Quartile Range Scoreprint(obj.find(x,"iqr"))2. Remove outlier in text datafrommernimportTextOutlierobj=TextOutlier()text="abcd!G#45!"# remove punctuation ex : !@#$%no_punctuation=obj.remove_punctuation([text])print(no_punctuation)# remove stop words ex : this, the, a, etc# tweets by @SomeGuyAbidestweets="Is a burning compressed liquid hydrogen as rocket fuel feasible for a propellant? Could this process be deleveloped through electrolysis of water? "no_sw=obj.remove_stopwords([tweets],lang="english")That's it.
Package: meroxa-py
Meroxa-pyInstallingInstall and update usingpip:$ pip install -U meroxa-pyA Simple ExampleimportasynciofrommeroxaimportMeroxafrompprintimportpprintauth="auth.token",asyncdefmain():asyncwithMeroxa(auth=auth)asm:resp=awaitm.users.me()pprint(resp)asyncio.run(main())To obtain a Meroxa Auth Token please see:How to Obtain a Meroxa Access Token
Package: merph
MERPHBayesian methods for inferring mass eruption rate from column height (or vice versa) for volcanic eruptionsIntroductionMERPHuses Bayesian methods to explore the relationship between the mass eruption rate (Q) of a volcanic eruption and the height reached by the volcanic eruption column (H) that is produced.The mass eruption rate is a quantity that is very important in volcanology and in the dispersion of volcanic ash in the atmosphere, but it is very difficult to measure directly.Often the mass eruption rate is inferred from observations of the height of the volcanic eruption column, since the eruption column is often much easier to measure.  The eruption column height is linked to the mass eruption rate through the fluid dynamics of turbulent buoyant plumes, but there are often external volcanological and atmospheric effects that contribute and complicate the relationship.Datasets of the mass eruption rate and eruption column height have been compiled and used to determine an empirical relationship these quantities, using linear regression.  This has then been used to infer the mass eruption rate from the plume height.MERPHgoes further, by using Bayesian methods to perform the regression.  Bayesian methods:allow us to incorporate a range ofuncertaintiesquantitatively into our model;provide a meaningful quantitative comparison of different models.Main FeaturesMERPHis a python package containing:adatamodule containing MER--Plume height data sets:SparksMastinAubryIVESPAastatsmodule that performs Bayesian linear regression of the data and posterior predictionexample jupyter notebooks to illustrate the usea command line interface to perform regression and posterior predicitiona user interface as a dash/plotly web-browser appAdvanced featuresin developmentadvanced regression methods using pymcInstallMERPHcan be installed from pypi using pip.It is recommended to create a virtual environment, e.g. with Anaconda/Miniconda (conda create --name merph "python=3.10"), and install in the environment.Basic, light-weight set upThe basic modules (with no notebooks or app interface) can be installed withpip install merphOther featuresInstall with example notebooks usingpip install merph[nb]Install with the app usingpip install merph[app]Install pymc features usingpip install merph[mc]Full installInstall with all features usingpip install merph[full]How to useI recommend looking first at the notebook examples, which show how theMERPHmodule can be used.  After installing, the examples can be launched using the command line interface:merph-example 1andmerph-example 2.The app can be launched using the command line interfacemerph-app.The commandmerphlaunches a command line interface for basic use.DependenciesBasic, light-weight set upargparse>=1.4.0matplotlib>=3.5.1Pint>=0.18numpy>=1.24.2pandas>=1.4.1scipy>=1.8.0seaborn>=0.11.2odfpy>=1.4.1openpyxl>=3.0.9click<8,>=4.0Other featuresAppdash>=2.3.0dash-bootstrap-components >=1.0.3plotly>=5.6.0NotebooksnotebookAdvanced featurespymc>4arviz>=0.13.0ContactsMark J. Woodhousemark.woodhouse@bristol.ac.ukRepositoryhttps://bitbucket.org/markwoodhouse/merph
Package: merqube-client-lib
merqube-client-libMerQube API Client Library (Python)OverviewThis is a python client library for MerQube's public API.
This is a WIP release of an internal client library. More functionality will be added here over the coming weeks.Table Of Contents:OverviewCreating IndicesHistory of ChangesThere are a set of examples inexampleswith full walkthroughs; see that directory for additional documentation.
Package: merquery
Install$pipinstallmerqueryUsageimportmerqueryasmqq=mq.Merquery()url=q.max_price(1000)\.min_price(100)\.root_category(mq.RootCategory.VINTAGE_AND_COLLECTBLES)\.status(mq.ItemStatus.ON_SALE)\.shipping_payer(mq.ShippingPayer.SELLER)\.condition(mq.ItemCondition.NEW)\.order(mq.ItemOrder.LIKES)\.page(2)\.keyword('秋本帆華')\.build()print(url)# Output: https://www.mercari.com/jp/search/?item_condition_id%5B1%5D=1&status_on_sale=1&shipping_payer_id%5B2%5D=1&page=2&keyword=%E7%A7%8B%E6%9C%AC%E5%B8%86%E8%8F%AF&sort_order=like_desc&max_price=1000&min_price=100Supported querieskeywordmax pricemin priceitem statusshipping payeritem conditionbrand namesort orderroot categorypageUnsupported queriessizechild categorygrand child category
Package: merra
The package provides readers and converters for the Land Surface Diagnostics
within the Modern-Era Retrospective analysis for Research and Applications
version 2 (MERRA-2). MERRA-2 is a NASA atmospheric reanalysis integrating
satellite data assimilation and aims at historical climate analyses.
MERRA-2 covers Land Surface Diagnostics for the period 1980-present
at 0.5 ° x 0.625 ° spatial- and 1-hourly temporal-resolution.The structure of the package is as follows:grid.py : implements the asymmetrical GMAO 0.5 x 0.625 gridinterface.py : classes for reading a single image, image stacks and time seriesreshuffle.py : provides a command line utility for reshuffling a stack of 1-hourly sampled native images to time series format with an arbitraty temporal sampling between 1-hour and dailydownload.py : command line utility for downloading MERRA-2 data from the NASA GES DISC datapoolInstallationFor developers, it is recommended to first clone the repository and then
use the provided environment.yml file to install all needed conda and pip
dependencies:gitclonehttps://github.com/TUW-GEO/merra.git--recursivecdmerracondacreate-nmerrapython=3.7# or any supported python versionsourceactivatemerracondaupdate-fenvironment.ymlpythonsetup.pydevelopSupported ProductsM2T1NXLND: MERRA-2 tavg1_2d_lnd_Nx: MERRA-2 2d, 1-Hourly, Time-Averaged, Single-Level, Assimilation, Land Surface Diagnostics V5.12.4ContributeWe are happy if you want to contribute. Please raise an issue explaining what
is missing or if you find a bug. We will also gladly accept pull requests
against our master branch for new features or bug fixes.GuidelinesIf you want to contribute please follow these steps:Fork the merra repository to your accountmake a new feature branch from the merra master branchAdd your featureplease include tests for your contributions in one of the test directories
We use py.test so a simple function called test_my_feature is enoughsubmit a pull request to our master branch
Package: merrymake
Python Service Library for MerrymakeThis is the official Python service library for Merrymake. It defines all the basic functions needed to work with Merrymake.UsageHere is the most basic example of how to use this library:frommerrymakeimportMerrymakefrommerrymake.merrymimetypesimportMerryMimetypesfrommerrymake.envelopeimportEnvelopedefhandle_hello(payloadBytes:bytearray,envelope:Envelope):payload=bytes(payloadBytes).decode('utf-8')Merrymake.reply_to_origin(f"Hello,{payload}!",MerryMimetypes.txt)defmain():(Merrymake.service().handle("handle_hello",handle_hello))if__name__=="__main__":main()Tutorials and templatesFor more information check out our tutorials atmerrymake.dev.All templates are available through our CLI and on ourGitHub.
Package: mersenne
Mersenne - generate static HTML from Markdown, LaTeX, code, …Usage# Build the virtualenv and install required modules,
# including this one in editable mode
0/make_venv.sh. Venv/bin/activate# Build the module
0/build.sh# Register the built module with PyPI
0/register.sh# Upload a new build to PyPI
0/upload.sh# Delete all built files
0/clean.shDevelopmentRun0/make_venv.shfirst. Venv/bin/activate
# This IPython config will set autoreload
ipython –config=0/ipython_config.py
Package: mertpiptest1
FILEPATH: /path/to/your/code/file.py"""
This is a basic README file that provides an overview of the code in this repository.Usage:Clone the repository to your local machineRun the code in your preferred Python environmentDependencies:Python 3.x[List any additional dependencies here]Contributing:Fork the repositoryMake changes and submit a pull requestLicense:[Specify the license for your code here]
"""
Package: meru-app
Install: pip install meru-appfrom meru_app import meruAdd API Keymeru.api_key = 'YOUR_API_KEY'Create indexmeru.createIndex(
file_url = 'YOUR_FILE_URL',
index_name = 'YOUR_INDEX_NAME' # Optional
)Get indexmeru.getIndex(
file_id = 'YOUR_FILE_ID'
)Delete indexmeru.deleteIndex(
file_id = 'YOUR_FILE_ID'
)Predictmeru.predict(
file_id = 'YOUR_FILE_ID',
prompt = 'YOUR_PROMPT',
temperature = 'YOUR_TEMPERATURE', # Optional
max_tokens = 'YOUR_MAX_TOKENS', # Optional
similarity_top_k = 'YOUR_SIMILARITY_TOP_K' # Optional
)Get predictionmeru.getPrediction(
predict_id = 'YOUR_PREDICT_ID'
)Delete predictionmeru.deletePrediction(
predict_id = 'YOUR_PREDICT_ID'
)
Package: mesa-interactive
Mesa InteractiveOverviewMesa Interactive is a specialized Python package designed to provide dynamic visualization and interaction capabilities for Mesa models. It extends the functionalities of theMesa frameworkfor agent-based modeling.Quick InstallationTo quickly install the package, open your terminal and run:pipinstallmesa_interactiveTutorial: Visualizing the Schelling Segregation ModelThis section provides a step-by-step walkthrough to visualize a Schelling Segregation model using Mesa Interactive.PrerequisitesEnsure that you havemesa-modelsinstalled. If not, run the following command:pipinstall-U-egit+https://github.com/projectmesa/mesa-examples#egg=mesa-modelsImporting DependenciesImport the essential libraries as follows:importsolarafrommesa_models.schelling.modelimportSchellingfrommesa_interactiveimportMesaInteractive,slide,staticfrommesa_interactive.componentsimportcreate_chart,create_grid,create_markdownBuilding ComponentsInstructions: Add Markdown instructions. We use thestatichelper function, since it doesn't rely on model parameters.Instructions=static(solara.Markdown("Click on an agent to switch its type."))GridView: Construct a grid view, enabling aswitch_agent_typefunction on agent click.defswitch_agent_type(model,x,y):agent=model.grid.get_cell_list_contents([(x,y)])[0]agent.type=1-agent.typeGridView=create_grid(color="type",on_click=switch_agent_type)HappyCount: Display the number of satisfied agents via a Markdown component.HappyCount=create_markdown(lambdamodel:f"**Happy Agents:{model.happy}of{len(model.schedule.agents)}**")HappyChart: Implement a time-series chart to track the number of happy agents.HappyChart=create_chart(variables=["happy"],"Happy Agents")Configuring Model ParametersDefine user-adjustable model parameters using default values and theslidehelper functions. It works like the built-inrangefunction but supports arbitrary steps and a default value.model_params={"width":20,"height":20,"density":slide(0,1,0.1,default=0.65),"minority_pc":slide(0,1,0.05,default=0.2),"homophily":slide(0,8,1,default=3),}Creating the Interactive PageInitialize the Mesa Interactive interface with the Schelling model, model parameters, and assembled components.page=MesaInteractive(Schelling,model_params,components=[HappyCount,Instructions,GridView,HappyChart],name="Schelling",show_dataframe="model",)To render your visulazation save your python file asapp.pyand from a terminal runsolara run app.pyAlternatively you can but everything in a Jupyter notebook and simply callpageto show the visualization.Now you have built a fully interactive visualization for the Schelling Segregation model!
Package: mesc
Python MESC ImplementationThis is a reference implementation of the Python MESC StandardIt has no external dependencies.InstallationExample UsageReferenceInstallationFrom PyPIpip install mescFrom Sourcegit clone https://github/paradigmxyz/mesc
cd mesc
pip install ./Example UsagefromtypingimportAny,Mapping,Sequenceimportmesc# check whether mesc is enabledenabled:bool=mesc.is_mesc_enabled()# get the default endpointendpoint:Endpoint|None=mesc.get_default_endpoint()# get the default endpoint of a networkendpoint:Endpoint|None=mesc.get_endpoint_by_network(5)# get the default endpoint for a particular toolendpoint:Endpoint|None=mesc.get_default_endpoint(profile='xyz_tool')# get the default endpoint of a network for a particular toolendpoint:Endpoint|None=mesc.get_endpoint_by_network(5,profile='xyz_tool')# get an endpoint by nameendpoint:Endpoint|None=mesc.get_endpoint_by_name('local_goerli')# parse a user-provided string into a matching endpoint# (first try 1. endpoint name, then 2. chain id, then 3. network name)endpoint:Endpoint|None=mesc.get_endpoint_by_query(user_str,profile='xyz_tool')# find all endpoints matching given criteriaendpoints:Sequence[Endpoint]=mesc.find_endpoints(chain_id=5)# get non-endpoint metadatametadata:Mapping[str,Any]=mesc.get_global_metadata(profile='xyz_tool')ReferencefromtypingimportAny,MutableMapping,TypedDict,Literal,SequenceclassRpcConfig(TypedDict):mesc_version:strdefault_endpoint:str|Noneendpoints:MutableMapping[str,Endpoint]network_defaults:MutableMapping[str,str]network_names:MutableMapping[str,str]profiles:MutableMapping[str,Profile]global_metadata:MutableMapping[str,Any]classEndpoint(TypedDict):name:strurl:strchain_id:str|Noneendpoint_metadata:MutableMapping[str,Any]classProfile(TypedDict):name:strdefault_endpoint:str|Nonenetwork_defaults:MutableMapping[str,str]