Saravanan666/pypi-org huggingface dataset:
Package: metos3d
Metos3DMarine Ecosystem Toolkit for Optimization and Simulation in 3-DAbout Metos3DWhat is Metos3D?Metos3D is a collection ofsimulation software (simpack)optimization software (optpack)chemical / biogeochemical / marine ecosystemmodelstransport and forcingdatathat is based on theTransport Matrix Method.What is Metos3D for?Metos3D can be used forsimulation ofcomputation of annual periodic steady-states ofparameter estimates forchemical / biogeochemical / marine ecosystem models coupled to global 3-D ocean circulation.See:[Piwonski and Slawig, 2016]Why was Metos3D developed?In the field of climate research and ocean simulation, marine ecosystem models still entail the most uncertainties.
Thereforean application programming interface for biogeochemical modelsBGC APIwas designed anda comprehensive, state-of-the-art, high-performance software based onPETScwas built around it.See:[Piwonski and Slawig, 2016]How do I use Metos3D?Have a look into theMetso3D Documentation.Reference[Piwonski and Slawig, 2016]Metos3D: the Marine Ecosystem Toolkit for Optimization and Simulation in 3-D – Part 1: Simulation Package v0.3.2ThanksThe authors would like to thank:Samar Khatiwalafor theTransport Matrix Method.Iris Kriestfor the support for biogeochemistry.Joscha Reimerfor the support for Anaconda.
Package: metovhooks
Personal Git HooksThis directory contains some scripts designed for use asgit hooks. They should have a pretty simple command line interface (see docstrings for details) so usage should be self-explanatory.InstallationYou can install the entire hook package withpip install metovhooks.UsageYou can run the scripts manually in your shell. For example,protect_branch masterwill exit with code 1 if the current git branch ismasterand exit with 0 if not (if your shell does not display exit codes, you can check the code withecho $?).Of course, it isn't very useful to run these manually. You can just typegit statusand see what the current branch is. But these scripts are intended to be used as git hooks. This is why the commands themselves are verbose - you'd be reading them much more often than typing them. However, you still have the option of just typing them manually -- a useful thing when troubleshooting.If you're looking for a tool to help you manage git hooks, check outyaghm. This repository also contains a yaghm config defining the hooks I use when developing it. This is optional; it won't actually do anything until you install yaghm and enable them.
Package: metovlogs
metovlogsDead simple Python logging.metovlogs is a very simple logging library. Setup is one line, then you can use it as a drop-inprintreplacement. Sane and useful log format out of the box. Best for small or early stage projects.UsageInitialize the logger by callingget_log:import metovlogs

# The name will be used to annotate the log
# __name__ is name of the current Python module
log = metovlogs.get_log(__name__)Now you can use it as a drop-in replacement for all yourprints:# Do some stuff
log.info("Finished doing some stuff")

log.debug("About to start doing other stuff")
# Do some other stuffmetovlogs is likeblackfor logs: You get reasonable behavior by default andminimal customization. This allows you to focus on developing without distraction. If you want to customize your logs more, you should use something else.Installationpip install metovlogsFurther readingBackgroundContribution guidelinesPlanned future work
Package: metpx-sr3
[ homepage (En):https://metpx.github.io/sarracenia] [(Fr) fr/][Getting Started]
[Source Guide][Un bon départ]
[Guide de Source]MetPX-sr3 (Sarracenia v3) is a data duplication
or distribution pump that leverages
existing standard technologies (web
servers and Message queueing protocol
brokers) to achieve real-time message delivery
and end-to-end transparency in file transfers.
Data sources establish a directory structure
which is carried through any number of
intervening pumps until they arrive at a
client.MetPX-sr3 (Sarracenia v3) est un engin de copie et de
distribution de données qui utilise des
technologies standards (tel que les services
web et le courtier de messages AMQP) afin
d’effectuer des transferts de données en
temps réel tout en permettant une transparence
de bout en bout. Alors que chaque commutateur
Sundew est unique en soit, offrant des
configurations sur mesure et permutations de
données multiples, Sarracenia cherche à
maintenir l’intégrité de la structure des
données, tel que proposée et organisée par la
source jusqu’à destination.
Package: metquest
MetQuest is a dynamic programming based algorithm for identifying all possible
pathways from metabolic networks between the source and the target metabolites.
MetQuest requires the genome-scale metabolic reconstructions,
set of seed, source and target metabolites and the pathway length cut-off.
MetQuest is compatible with Python 3 and is OS-independent.For detailed documentation, visithttp://metquestdoc.readthedocs.io/
Package: metrace
Metrace - cpu/memory tracing for process treesMetrace makes it easy to get a nice interactive html plot of the cpu/memory usage of a whole process tree.InstallMetrace depends onPlotlyandPsutil, both will be installed with metrace using pip:$ pip install metraceClient usage (optional)Metrace lets you annotate specific parts of your code with scopes and these will become part of your final plot output and end up look like this:Metrace gives you a context managertraceyou can wrap code blocks with:$ cat foobar.py

from metrace import trace

with trace('creating 1000 objects'):
    l = []
    for i in range(1000):
        l.append(object())To collect these traces you run your script with metrace as usual:$ metrace run python foobar.pyCommandline UsageAfter installation you will have themetracecommand available.$ metrace run python main.py && metrace plotIt has two subcommands:run$ metrace run python foobar.pyRuns a process and collects cpu/memory metrics for both the process and its children seperately.Metrace outputs the metrics in a json file in current working directory named like:metrace_1568385178098218.jsonwith the number being milliseconds since epoch.plot$ metrace plot
# or
# to not open the html report automatically:
$ metrace plot --autoopen=no
# or
# to specify input/output files
$ metrace plot -i metrace_1568385178098218.json -o metrace_report.htmlPlots cpu/memory usage for a given, or latest found,metrace json file.Output is a html file where you can download the images, zoom in and hover to inspect the different traces.SamplesDocs folder contains a sample of ametrace json fileand ametrace html reportAttributionplotly.min.jsLicensed under MIT, has been included in this library here:metrace/plotly_latest.min.js
Package: metran
MetranMetran is a package for performing multivariate timeseries analysis using a
technique called dynamic factor modelling. It can be used to describe the
variation among many variables in terms of a few underlying but unobserved
variables called factors.DocumentationThe documention can be found onmetran.readthedocs.ioExamplesFor a brief introduction of the theory behind Metran on multivariate timeseries analysis with
dynamic factor modeling see the notebook:The Dynamic Factor ModelA practical real-world example, as published in Stromingen (Van Geer, 2015), is given in the following notebook:Metran practical exampleA notebook on how to usePastasmodels output with Metran:Pastas Metran exampleInstallationTo install Metran, a working version of Python 3.8 or higher has to be installed on your computer.
We recommend using theAnaconda distributionas it includes most
of the python package dependencies and the Jupyter Notebook software to run the
notebooks. However, you are free to install any Python distribution you want.To installmetran, type the following commandpip install metranTo install in development mode, clone the repository and type the following from the module root directory:pip install -e .DependenciesMetran has the following dependencies which are automatically installed if
not already available:numpy,scipy,pandas,matplotlib,numbaandpastasReferencesBerendrecht, W.L. (2004).State space modeling of groundwater fluctuations. Doctoral Thesis, Delft University of Technology.Berendrecht, W.L., F.C. van Geer (2016).A dynamic factor modeling framework for analyzing multiple groundwater head series simultaneously. Journal of Hydrology, 536, pp. 50-60.Van Geer, F.C. en W.L. Berendrecht (2015)Meervoudige tijdreeksmodellen en de samenhang in stijghoogtereeksen. Stromingen 23 nummer 3, pp. 25-36.
Package: metrapy
metrapyA batteries included wrapper around MetaTrader5's python utility.[+] Wrapper Functions: Get account, tickers, orders, positions, history & deals[+] Polling utility that uses thread to fetch data periodically[+] Wrapper utility for placing orders, Maps for MT5 constantsWhat does it tries to solve?It tries to make working with Python + MT5 easier, by adding default validation & error messages, parsing responses, and wrapping them appropriately.InstallationpipinstallmetrapyConnectionfrommetrapy.connectorimportMT5mpy=MT5({'server':'ServerName-Global','login':1876876,'password':'yourpass'})# Default terminal path location is already provided. However, you can override that with your own.mpy=MT5({'path':'your-terminal-location','server':'ServerName-Global','login':1876876,'password':'yourpass'})[x] Make sure you have Algorithmic trading enabled in MT5 terminalExposed Defaultstimezoneis UTC 0 by default, you can override it with your own.mt5core package is exposed as_mt5property. so, you do not need to import it explicitly.mt5=mpy._mt5All the mappings are exposed viampy.mapsproperty.mpy.connectedprovides connected statusYou can passmagic&debugparameters to the MT5() constructor, for helpful debugging.Polling UtilityMT5 does not provide for data fetching in realtime mode. So, the options arePoll your data, on regular time intervalsMake a bridge between MQL5 & Python to fetch that data (using sockets, streams or something else)Support for 1 is available and should be useful enough in most of the cases.frommetrapy.syncimportpollerpoller(your_func,timeframe,adjusted_secs=0)your_func is piece of code to execute at any given timeframesupports integer (number of secs), or timeframe (1s, 1M, 2M, 5M, 15M, 30M, 1H, 4H, 1D, 1W)defstart():print("5 minutes spent")poller(start,"5M")poller(start,100,2)It must be noted that code will run at regular time intervals, not from when you start the code. For example, above code will run at HH:05, HH:10, HH:15, HH:20, ...
Package: metrc-client-python
metrc-pythonPython backend for connecting with MetrcInstructions for example Flask serverInstallpipenvClone this repostitory, go to the root folder, and run the following commandspipenv shellpip install -r requirements.txtNow edit the fileexample/flask/configs.yml.exampleto have key value pairs of the states you have vendor keys in to those vendor keys and rename toexample/flask/configs.ymlNow run the following and the server should runcd example/flaskflask run
Package: metric4coref
metric4coref共指消解任务CoNLL的官方评测库是Perl语言完成的，但是近些年基于Python语言为主的深度学习在共指消解任务上的应用越来越普遍，所以同时也非常需要一个基于Python的便捷评测库。使用方法安装pipinstallmetric4coref使用frommetric4corefimportmuc,ceaf,b_cubed,conll_coref_f1# "a", "b" 等代表mention id# predict_clusters、gold_clusters分别代表模型生成mention簇和标注mention簇predict_clusters=[["a","b","c"],["d","e","f","g"],["h","i","j"],["k"]]gold_clusters=[["a","b","d"],["c","e","f","g"],["h","i","j","k"]]print(muc(predict_clusters,gold_clusters))# -> 准确率、召回率、f1：(0.5833333333333334, 0.4666666666666667, 0.5185185185185186)print(b_cubed(predict_clusters,gold_clusters))# -> 准确率、召回率、f1：(0.7424242424242423, 0.606060606060606, 0.6673476336397685)print(ceaf(predict_clusters,gold_clusters))# -> 准确率、召回率、f1：(0.7272727272727273, 0.7272727272727273, 0.7272727272727273)print(conll_coref_f1(predict_clusters,gold_clusters))# -> 以上三个f1平均值： 0.6377129598103382共指消解的评测方法the link based MUC论文1995B cubed metric论文1998the entity based CEAF metric论文2005BLANCLink-Based Entity-Aware metric (LEA).共指消解任务任务主页CoNLL 2012 Co-reference task官方metricAverage F1 of MUC, B-cubed, and CEAF算法解读the link based MUC解释：基于簇中两两mention连接的边作为评测依据precision：
分子：所有系统预测边与所有标注边的交集的个数
分母：所有预测边的个数recall：
分子：所有系统预测边与所有标注边的交集的个数
分母：所有标注边的个数f1:
precision * recall * 2 / (precision + recall)例子：预测边：
ab、bc、ac、de、df、dg、ef、eg、fg、hi、ij、hj共12个标注边：
ab、ad、bd、ce、cf、cg、ef、eg、fg、hi、hj、hk、ij、ik、jk共15个预测边和标注边的交集：
ab、ef、eg、fg、hi、hj、ij共7个precision: 7/12=0.5833333recall: 7/15=0.4666667f1: 0.5833333 * 0.4666667 * 2 / (0.5833333 + 0.4666667)=0.5185185特点：不考虑单个mention的簇，因为没有边倾向于生成很多mention的簇，容易得高分B cubed metric解释：以mention为单位，每个mention计算一个precision和recall，在加权平均所有mention的precision和recall每个mention的计算方法：precision：
分子：系统预测的包含mention的簇与人工标注的包含mention的簇的mention交集个数
分母：系统生成的包含mention的簇的个数recall：
分子：系统预测的包含mention的簇与人工标注的包含mention的簇的mention交集个数
分母：人工标注的包含mention的簇的个数f1:
precision * recall * 2 / (precision + recall)例子：mention a:
所在预测簇: ["a", "b", "c"]
所在标注簇: ["a", "b", "d"]
precision:
分子: a、b共2个
分母: a、b、c共3个
=2/3=0.666
recall:
分子: a、b共2个
分母: a、b、d共3个
=2/3=0.666mention b:
所在预测簇: ["a", "b", "c"]
所在标注簇: ["a", "b", "d"]
precision:
分子: a、b共2个
分母: a、b、c共3个
=2/3=0.666
recall:
分子: a、b共2个
分母: a、b、d共3个
=2/3=0.666mention c
所在预测簇: ["a", "b", "c"]
所在标注簇: ["c", "e", "f", "g"]
precision:
分子: c共1个
分母: a、b、c共3个
=1/3=0.333
recall:
分子: c共1个
分母: c、e、f、g共4个
=1/4=0.25
...对所有mention的precision、recall求平均值特点：对每个mention等权重看待the entity based CEAF metric解释：标注的实体簇为R、系统生成的实体簇为S,R中每个mention为r、S中每个mention为sR的个数与S的个数的少者为m建立从R到S的一一映射map，每个映射对应从R中的r到S中的s，映射的个数为m计算每个映射中，r和s中相同mention个数计算整个map映射中，所有相同mention的个数遍历所有可能的map，取所有相同mention的个数的最大的映射map，相同mention个数为nprecision = n/S的mention个数recall = n/R的mention个数例子：预测的实体簇个数为4标注的实体簇个数为3
那么m=3遍历可知，映射关系为
标注实体簇1 --> 预测实体簇1
标注实体簇2 --> 预测实体簇2
标注实体簇3 --> 预测实体簇3计数：
正确的mention有：
a、b、e、f、g、h、i、j共8个
预测的mention个数共11个
标注的mention个数共11个指标：
precision=8/11=0.7272727
recall=8/11=0.7272727
Package: metric-builder
Metric BuilderUtility for building templated metric extraction queries that can be traversed through time.PrerequisitesYou will need the following to run this code:Python 3InstallationTo be determined...UsageIn order to extract a given metric, aMetricobject needs to be instantiated:metric=Metric(query="""SELECT count(*) AS totalFROM `project.dataset.table`WHERE DATETIME_TRUNC(created_datetime, DAY) = '{{ reference_time | format_date('%Y-%m-%d') }}'""",reader=BigQueryReader(json_credentials_path='/path/to/creds.json'))Thequeryparameter is a templated query where you can format thereference_timedatetimeobject to the required format using template filters.Thereaderparameter is the object that is actually going to connect to the desired database and perform the queries.Themetricobject can now be used to fetch metrics for a given point in time as follows:result=metric.fetch(reference_time=datetime.date(2019,10,21))The result is returned as a list of dictionaries.Template filtersJinja2is used as the templating engine. All built in Jinja filters are thus available. Relevant custom template filters have been added though for convenience:format_dateSpecify format of datetime:'{{ reference_time | format_date('%Y-%m-%d') }}'day_deltaChange a given datetime object by a specified number of days:'{{ reference_time | day_delta(-7) | format_date('%Y-%m-%d') }}'ReadersAny reader will implement the following method that is used to execute queries:defexecute(self,query)->List[Dict[str,Any]]:...BigQueryReaderThe underlying client is required to be authenticated with the necessary priviledges to read from the requested BigQuery tables.If you authenticate with:gcloudauthloginorexportGOOGLE_APPLICATION_CREDENTIALS="/path/to/keyfile.json"then you can just instantiate yourReaderlike this:reader=BigQueryReader()The other option is to explicitly authenticate with a service account key file:reader=BigQueryReader(json_credentials_path='/path/to/creds.json')HiveReaderComing soon...
Package: metriccoders-ml
Metric Coders Model LoaderOverviewWelcome to Metric Coders Model Loader PyPI Package source code. Your one-stop solution for effortlessly loading machine learning models directly from GitHub repository of Metric Coders Model Hub. This Python package is designed to simplify the process of fetching and integrating pre-trained models hosted on GitHub, allowing you to focus on the magic of your machine learning applications.FeaturesGitHub Integration: Seamlessly fetch machine learning models hosted on GitHub with just a few lines of code.Versatility: Compatible with various machine learning frameworks and models stored in GitHub repositories.Easy to Use: Minimal setup and intuitive functions for quick integration into your projects.Customizable: Adapt the loading process to suit your specific project requirements.Installationpipinstallmetriccoders_mlUsageLoad a Model from GitHubfromml_algorithms.algorithmsimportMLPowerEnginefromsklearn.datasetsimportload_iris# Specify the GitHub repository URLrepo_url="https://github.com/metriccoders/ml-models/blob/main/classifiers/discriminant_analysis_109/model0.437902612044043_False_0.0029324921266509207/model.joblib"# Load the model from GitHubengine=MLPowerEngine(repo_url)ml_engine=engine.load_model()iris=load_iris()print(ml_engine.predict(iris.data))ContributionContributions are welcome! If you have ideas for improvements, bug fixes, or new features, feel free to submit a pull request.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.SupportFor any questions, issues, or feedback, please open anissue.Let's make loading machine learning models from Metric Coders Model Hub a breeze! 🚀
Package: metricd
metricd is agent for collecting and sending metrics. Currently collects information about system and sends as JSON via HTTP. In the future more reporters (e.g statsd, graphite, riemann, influxdb) and collectors (e.g. metricd-nginx, metricd-haproxy, metricd-mysql, metricd-redis) will be available.Installationpip is easiest way to install metricd.Dependenciespython 2.7, >=3.3 (tested with version 2.7, 3.3, 3.4, 3.5)Python development tools and libraries (called python-dev or devel)pipInstalling dependenciesUbuntu / Debian:$ sudo apt-get install python-dev python-pipRedHat / CentOS:$ sudo yum install python-pip python-devel gcc
# You can find python-pip from EPEL repositoryOSXFirst of all, you need to installXcodeInstalling with pip:$ sudo pip install metricdUpgrading:$ sudo pip install metricd --upgradeUninstalling:$ sudo pip uninstall metricdRunningThe following command prints metrics to console:metricd consoleIf you want to send metrics with HTTP POST as JSON:$ metricd http --url http://localhost:3000/collect

## with extra headers

$ metricd http --url http://localhost:3000/collect --headers X-Foo=Bar --headers X-Access-Token=jaezei9GLicenseThe MIT License (MIT)
Copyright (c) 2016 Osman UngurPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: metricfactory
What?A set of Wishbone modules to build metric processing servers.How?MetricFactory uses the WishBone library to build servers which allow you to
accept, convert and process metrics from one source and submit them to another
destination.MetricFactory is collection of encoder, decoder and filter modules to build a
pipeline of functionality.  Besides these modules you will also require one or
more Wishbone modules fromhttps://github.com/smetj/wishboneModuleswhich
allow you to accept and submit the metrics outside of the framework.Decoders convert metrics into an internal format.  Encoders convert them again
to a native format.Using a bootstrap file you select and connect different modules into an event
pipeline and start a Metricfactory server from commandline.For more information seehttps://wishbone.readthedocs.org/en/latestInstallationFrom Pypi:$ easy_install metricfactoryFrom Github:$ git clonehttps://github.com/smetj/metricfactory$ cd metricfactory$ python setup.py installUsageHave a look at the available modules:$ metricfactory list –group metricfactory.encoder$ metricfactory list –group metricfactory.decoder$ metricfactory list –group metricfactory.test$ metricfactory listTo start 2 parallel instances of a server in the background:$ metricfactory start –config /path/to/boostrapfile.yaml –instances 2Exampleshttps://github.com/smetj/experiments/tree/master/metricfactory
Package: metricfarmer
Cares about your project metricsDocumentation:https://metricfarmer.readthedocs.ioMetric-Farmer is a Python based command line application to collect and store metrics from different sources
to different targets.It is designed to easily create and maintain complex metric measurements and to painless integrate its functions into
continuous integration systems (CI/CD) or local task executions (cron jobs).The configuration is completely done by JSON-basedfarm-files in a project folder called.farmer.
And no development skills are needed to use Metric-Farmer.Developers can easily create own Metric-Farmer extensions to provide custom solutions for sources and targets.
For instance to measure a company-internal service.FeaturesMetric-Farmer is capable to collect metrics from following sources:static valuesrandom valuesfile countREST requests (E.g. to measure JIRA or GitHub)And sends the results to the following targets:print output (text or json)file output (text or json)database output (sqlite)