Saravanan666/pypi-org huggingface dataset:
Package: metaci-cli
MetaCI CLIA command line interface for MetaCI, a CI app run on Heroku for Salesforce development projectsFree software: BSD licenseDocumentation:https://metaci-cli.readthedocs.io.FeaturesAuto-detects and loads CumulusCI’s configuration when inside a project’s local git repositoryDeploy a MetaCI site to Heroku withmetaci site addConnect to an existing MetaCI site withmetaci site connectInteract with builds withmetaci buildInteract with orgs withmetaci orgInteract with plans withmetaci plansInteract with services withmetaci servicesCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.4 (2018-08-24)Update for CumulusCI 2.0.8+0.1.3 (2018-03-23)Fix bug in metaci plan repo_add, repo_list, and run commandsAdd new command: metaci repo plans0.1.2 (2018-03-20)Fix import error for “cli” which was being caused by a misconfiguration in the egg0.1.1 (2017-11-07)Fix a few bugs related to the change in structure for plans and repositories in MetaCIRequire cumulusci-2.0.0b750.1.0 (2017-10-21)First release on PyPI.
Package: metaclass
Metaclasses are a very powerful tool in Python. You can control
the entire class creation process with them.Most of the time, however, they are too powerful. This module helps
you to use some of the advantages of metaclasses, without having
to know all the details. It defines a base classSubclassInit.
Inheriting from this class one can modify the subclass creation
process.Initializing subclassesA very common usecase for a metaclass is that you just want to execute
some code after a class is created. This can easily done withSubclassInit. You just define a method__init_subclass__,
which is implicitly considered a@classmethodand
will be called after each subclass that is generated of your
class. As a parameter it gets the namespace of the class. An example
is a simple subclass registration:class Register(SubclassInit):
    subclasses = []

    def __subclass_init__(cls, ns, **kwargs):
        super().__subclass_init__(ns, **kwargs)
        Register.subclasses.append(cls)Note how you can add keyword arguments. Those are the keyword
arguments given on the class definition line, as in:class Subclass(Base, spam="ham"):
    passDon’t forget to properly callsuper()! Other classes may want to
initialize subclasses as well. This is also why you should pass over
the keyword arguments, just taking out the ones you need.Initializing DescriptorsDescriptors are a powerful technique to create object attributes which
calculate their value on-the-fly. A property is a simple example of such
a descriptor. There is a common problem with those descriptors: they
do not know their name. UsingSubclassInityou can add an__init_descriptor__method to a descriptor which gets called once the
class is ready and the descriptor’s name is known.As an example, we can define a descriptor which makes an attribute a
weak reference:import weakref

class WeakAttribute:
    def __get__(self, instance, owner):
        return instance.__dict__[self.name]()

    def __set__(self, instance, value):
        instance.__dict__[self.name] = weakref.ref(value)

    def __init_descriptor__(self, owner, name):
        self.name = nameOrder of AttributesSometimes one is interested in which order the attributes were defined
in the class.SubclassInitleaves a tuple with all the names of the
attributes in the order they were defined as a class attribute called__attribute_order__. Note that Python already defines some class
attributes, like__module__, some of which also show up in this
tuple.As an example:class AttributeOrder(SubclassInit):
    a = 1

    def b(self):
        pass

    c = 5

assert AttributeOrder.__attribute_order__ == \
    ('__module__', '__qualname__', 'a', 'b', 'c')
Package: metaclassifier
MetaClassifierOverviewMetaClassifier is an integrated pipeline for identifying the floral composition of honey using DNA metabarcoding to determine the plants that honey bees visit. MetaClassifier utilizes a database of marker sequences and their corresponding taxonomy lineage information to classify high-throughput metabarcoding sample sequencing reads data into taxonomic groups and quantify taxon abundance. MetaClassifier can also be employed in other studies that utilize barcoding, metabarcoding, and metagenomics techniques to characterize richness, abundance, relatedness, and interactions in ecological communities.In addition to this README file, you can consult the MetaClassifiermanualfor more detailed information.InstallationMetaClassifier requires dependencies and external tools that need to be installed and available on the environment the pipeline can be used. Not a requirement if insatalling using Bioconda.DependeciesPython(version >=3.7)pandas(version >=1.2.2)External toolsPEARfor merging overlapping paired-end (PE) readsseqtkfor converting FASTQ to FASTA sequence formatVSEARCHfor searching searching high-throughtput sequence read data against marker databasePython package installationMetaClassifier is available throughpypi. To install, type:pip install metaclassifierRepository from GitHubEither "git clone https://github.com/ewafula/MetaClassifier.git" or download and "unzip MetaClassifier-main.zip"
cd MetaClassifier/
python setup.py installBioconda packageThis requires a workingCondainstallation.conda install -c bioconda metaclassifierWe recommend installing MetaClassifier in a new separate environment from the base for all dependencies to be properly resolved by conda. To install, type:conda create -n "metaclassifier" -c bioconda metaclassifier=1.0.1Marker reference databasesMetaCuratorreference databases with taxonomy lineage information reformated to work with MetaClassifier.
Detailed step by step tutorial workflow for creating reference marker database is descrribe on the GitHubMetaCurator database repositoryMetabarcodeDBsBasic usagemetaclassifier [options] <SAMPLE_FILE> <DB_DIR> <CONFIG_FILE>Please consult the MetaClassifiermanualfor a detailed description and usage of all options.CitationIf you use MetaClassifier please cite the following paper the describes the methodology:Characterizing the floral resources of a North American metropolis using a honey bee foraging assay.Douglas B. Sponsler,Don Shump,Rodney T. Richardson,Christina M. Grozinger.Ecosphere 11, no. 4 (2020): e03102.DOI:https://doi.org/10.1002/ecs2.3102LicenseMetaClassifier is distributed under the GNU GPL v3.0 For more information, seelicense.
Package: metaClean
Meta CleanerPython project to clean meta data off of pictures inserted in particular folder.This script is in the very early stages.This script can be run as a systemd service or on its own.Run the script by going to its directory and entering python3 metaClean.pyThe following flags are available to use.-c or --configureThis flag configures the file config.yml setting the watched directory, recursivity, and whether this will be run as a systemd service or not-s or --startThis flag starts watching the set directory if the configuration paramaterserviceis set to falseIfserviceis set to true, the script starts the systemctl daemon.-sh or --showThis flag shows the current configuration of config.yml-ser or --serviceThis flag is used for the systemctl daemon, it bypasses all if other setups and just watches the set directory. This flag is not intended to only be used by the systemd daemon.Ex.
python3 metaClean.py -sh -c -sThis command willshow your current config.ymlAllow you to edit config.ymlStart the service. Ether as a deomon or standalone service. All depending what you configure it as.Future WorkAdd the ability to monitor multiple folders for multiple files. Ex Photos, PDF's, Word Docs etc.Integrate mat2's libraries for more extensive and vetted meta cleaningAdd in phone functionality. Make the script clean all meta data for every photo taken by a phone.
Package: metaclock
MetaClockMetaClock is an integrated framework for reconstructing time-resolved evolutionary history for microbial genomes using large-scale (meta)genomics data from ancient and contemporary samples.Main featuresAutomated reconstruction of whole-genome alignment from large-scale metagenomics data using multiple reference genomesAutomated authentication for ancient DNA origin, damaged sites removal, SNV analysis etc.Rich utilities for manual curation to enhance the quality of phylogenetic and molecular dating analysisInstallationBiocondaYou can install MetaClock using conda as follows:ThepackagewillbepublicallyavailableoncethemanuscriptissubmittedRepositoryYou can clone the MetaClock repository from GitHub:ThepackagewillbepublicallyavailableoncethemanuscriptissubmittedDependencies:TutorialsMetaClock User manualMetaClock TutorialsSupportCitation
Package: meta-compose
# meta-composeThis package aims to solve the problem of variable substitution indocker-compose files by parsing them as [Jinja2](http://jinja.pocoo.org/)template.It was inspired by the discussion[here](https://github.com/docker/compose/issues/1377)It supports variable declaration in a separate YAML file as well asaccess to environment variables.## Quickstart:- Install with `pip install meta-compose`- Create a file `meta-compose.yml` that is a [Jinja2](http://jinja.pocoo.org/)template for a docker compose file.- [Optional] Create a file `meta-compose-data.yml` that contains the variablesused in the template that are not environment variables.- Call `meta-compose` and it will create a docker-compose.yml in the currentdirectory## Usage```usage: meta-compose [-h] [-d DATAFILE] [-t TEMPLATE] [-o OUTPUTFILE]optional arguments:-h, --help            show this help message and exit-d DATAFILE, --datafile DATAFILEUse to specify data files in addition to meta-compose-data.yml. They must be JSON or YAML files.-t TEMPLATE, --template TEMPLATEUse to specify the template file to use. Defaults to./meta-compose.yml-o OUTPUTFILE, --outputfile OUTPUTFILEUse to specify the output file to create. Defaults to./docker-compose.yml```## Syntax of meta-compose.yml- Everything in basic [Jinja2](http://jinja.pocoo.org/) is allowed.- To access environment variables use `{{'default'| env('VARIABLE_NAME')}}`where `VARIABLE_NAME` is the name of your environment variable and `default`is the default value you want it to be if the environment variable is not set.
Package: metaconfig
Metaconfig is a library for centralising your Python’s ConfigParser
files.  It is inspired by the logging module where it is increadibly
easy to start writing code that depends on logging whilst deferring
how log messages will be handled until later.To get started with metaconfig just do:import metaconfig
conf = metaconfig.get_config(__name__)conf will be a ConfigParser instance.  You can create a centralised
config file to configure multiple applications and libraries.Further documentation is available athttp://packages.python.org/metaconfig/.
Package: meta-critique
The Critique of CritiqueThis is the official repository forThe Critique of Critique.Table of contentsIntroductionLeaderboardQuick StartCitationIntroductionWe introduceMetaCritique, a new judge that can effectively evaluate human-written or LLMs-generated critique by generating critique.Meta-P: precision score of MetaCritique that evaluatesfactualityof hypothesis critique.Meta-R: recall score of MetaCritique that evaluatescomprehensivenessof hypothesis critique.Meta-F1: overall rating that is harmonic mean of precision score and recall score.LeaderboardWe release the benchmarking results of multiple critique models.Critique ModelMeta-PrecisionMeta-RecallMeta-F1 scoreAUTO-J76.4370.6571.14GPT 3.580.7964.2768.72UltraCM73.6466.7767.79Human Critique from Shepherd83.1960.6564.02SelFee69.5651.0554.22Quick StartInstallationpipinstallmeta-critiqueUsagefrommeta_critiqueimportMetaCritiqueapi_key=...# here is your OpenAi keyinputs=[{"question":"<question>","response":"<response1>","hypothesis_critique":"<hypothesis_critique>"},{"question":"<question>","response":"<response2>","hypothesis_critique":"<hypothesis_critique>"},...]meta_critique_instance=MetaCritique(model_type="gpt-4",batch_size=5,api_key=api_key,api_base=None,seed=None,cache_dir="tmp_cache",)precision_score,recall_score,f1_score=meta_critique_instance.score(inputs)wherequestion: The user query for the model to generate the response.response: The response generated by the model.hypothesis_critique: The critique written by either human or LLMs.reference_answer: (Optional) The reference answer.reference_critique: (Optional) The reference critique.str: a critique textdict: {"critique": <reference_critique>, "aius": <optional_aius_from_reference_critique>}You can find a test sample from eval_examples/test_samples.jsonCitationIf you find our work useful or use meta-critique, please cite our paper:@article{sun2024metacritique,
  title={The Critique of Critique},
  author={Shichao Sun, Junlong Li, Weizhe Yuan, Ruifeng Yuan, Wenjie Li, Pengfei Liu},
  journal={arXiv preprint arXiv:2401.04518},
  year={2024}
}
Package: metaCTD
Python toolbox to read, process and plot several different
conductivity, temperature and depth (CTD) formats including Seabird
and Sea &amp; Sun Technology files. The main task is to search valid
data in a certain folder and to define metadata as stations,
transects, campaigns.The backbone of the metaCTD toolbox are tools to read and process
different CTD fie formats from different vendors. This includes tools
to forSeabirdcnv files andSea & Sun Technology(SST) microstructure profilers (MSS).1InstallThe package was developed using python 3.5+, it might work with
earlier versions, but its not supported. The newestGibb Sea Water Toolbox (gsw)depends also on python 3.5+, pycnv heavily depends on the gsw toolbox. It
therefore strongly recommended to use python 3.5+.1.1UserInstall as a userpythonsetup.pyinstall--userUninstall as a userpipuninstallmetaCTD2SeabirdThe cnv text files are the standard output files of the Seabird CTD
software. The files are processed with the “pycnv” package.3Sea & Sun Technology (SST)The mrd binary files are the standard output files of the MSS-Profiler
software. The files are processed with the “pysst” tools.
Package: metad
An open source project from Data to AI Lab at MIT.MetaDataThis project aims to formally define a JSON schema which captures the structure of a relational database.JSON Schema:https://data-dev.github.io/MetaData/schema.htmlDocumentation:https://data-dev.github.io/MetaDataHomepage:https://github.com/data-dev/MetaDataLicense:MITInstallRequirementsMetaDatahas been developed and tested onPython 3.5, 3.6, 3.7 and 3.8Also, although it is not strictly required, the usage of avirtualenvis highly recommended in order to avoid interfering with other software installed in the system
in whichMetaDatais run.Install with pipThe easiest and recommended way to installMetaDatais usingpip:pipinstallmetadThis will pull and install the latest stable release fromPyPi.If you want to install from source or contribute to the project please read theContributing Guide.QuickstartIn this short tutorial we will guide you through a series of steps that will help you
getting started withMetaData.Creating Metadata ObjectsYou can also help create Metadata objects from scratch. The following code will create aMetaDataobject, add a table, and then save it to a JSON file.frommetadimportMetaDatametadata=MetaData()metadata.add_table({"id":"users","name":"users","primary_key":"id","fields":[{"name":"id","data_type":"id"},{"name":"name","data_type":"text"}],})Then, to export this object to a JSON file, you can run the following:metadata.to_json("your_metadata.json")Validating JSON FilesThe core functionality of this library is to validate JSON files. The following code will load
the metadata file for thehello_worlddataset and validate it.frommetadimportMetaDatametadata=MetaData.from_json("your_metadata.json")metadata.validate()What's next?For more details aboutMetaDataand all its possibilities and features, please check thedocumentation site.History0.0.1 (2020-06-08)Populate data subtype in MySQL connector -Issue #11by @k15zModifying the schema to support non-unique table names -Issue #13by @k15z0.0.1 (2020-05-22)First release on PyPI.
Package: metadata-expander
Auto fetch Meta data EntriesThis repository is intended as a starting point for fetching metadata from online sites.It is to be integrated into the ColLi backend for the collaborative Literature management.InstallThe following packages have to be installed:python3
BeautifulSoup4
URLlib
python bibtexparserto install under Ubuntu:aptinstallpython3python3-bs4python3-urllib3python3-bibtexparserAlternatively, just install python3 and do the rest via pip from the project directory:pipinstall-rrequirements.txtAdding more sites.If there is no parser for a specific site, it can be created in the sites folder.Naming convention is, that the file name and the class name inside this file must be the domain name without any subdomains or top-level domains.
So forhttps://dl.acm.org/it is justacmAn example is provided in sites/example.pyEvery class must be a subclass oflandingPageand can implement one of the following functions:defgetBibTeX(self,link,soup):returnNonedefgetDict(self,link,soup):returnNoneParameters are in both cases the URL of the landing page of the DOI resolver and the page as a parsed beautifulsoup object.They are seperated by their return value.getBibTeX must return a valid BibTeX entry or None.
getDict must return a python Dictionary with the field names according to the Dublin Core Standard.
Package: metadata-filter
metadata-filterCleaner metadata (e.g. artist, album, track titles) for scrobbling.Installpipinstallmetadata-filterUsagefrommetadata_filterimport*artist="Iron Maiden"album="Powerslave (2015 Remaster)"track="Aces High - 2015 Remaster"rules=(REMASTERED_FILTER_RULES+SUFFIX_FILTER_RULES+VERSION_FILTER_RULES+ORIGIN_FILTER_RULES+FEATURE_FILTER_RULES+CLEAN_EXPLICIT_FILTER_RULES+LIVE_FILTER_RULES+TRIM_WHITESPACE_FILTER_RULES)track=apply_filters(rules,track)album=apply_filters(rules,album)print(f"{artist}-{album}-{track}")# Prints:# Iron Maiden - Powerslave - Aces High
Package: metadata-guardian
Metadata GuardianOverviewMetadata Guardian is a Python package that provides an easy way to protect your data sources by searching its metadata.
By searching with data rules, it will detect what you are looking to protect.
Using Rust, it makes blazing fast multi-regex matching.UsageBenefit from data sources available of the Python ecosystem while Rust provides fast multi-regex processing withregexand parallelizes the process withrayon.Data RulesPIIINCLUSIONPython DevelopmentInstall virtualenv:makesetup-venvDevelopment mode with the library installed in virtualenv:makedevelopLaunch the tests:makeunit-testFormat and Runs checks:makeformat
makecheck-rust
makecheck-pythonBuild the documentation locally:makebuild-documentation
Package: metadata-inspector
metadata-inspektorA python based cli to inspect climate data metadata using xarrayUsing the command line interface.The python package is supposed to be used as a command line interface.
Meta data of various datasets can be inspected. To inspect the meta data use themetadata-inspectorcommand:metadata-inspector --helpusage: metadata-inspector [-h] [--html] [--version] input [input ...]Inspect meta data of a weather/climate datasetspositional arguments:input          Input files that will be processedoptions:-h, --help     show this help message and exit--html         Create html representation of the dataset. (default: False)--version, -V  show program's version number and exit
Package: metadata-please
metadata_pleaseThere are a couple of pretty decent ways to read metadata (importlib-metadata,
andpkginfo) but they tend to be pretty heavyweight.  This lib aims to do two
things, with as minimal dependencies as possible:Support just enough metadata to be able to look up deps.Do "the thing that pip does" when deciding what dist-info dir to look at.Version CompatUsage of this library should work back to 3.7, but development (and mypy
compatibility) only on 3.10-3.12.  Linting requires 3.12 for full fidelity.Licensemetadata_please is copyrightTim Hatch, and licensed under
the MIT license.  I am providing code in this repository to you under an open
source license.  This is my personal repository; the license you receive to
my code is from me and not from my employer. See theLICENSEfile for details.
Package: metadata-registry-interface-specifications
Metadata Registry Interface SpecificationsIntroductionProject Name: Metadata Registry Interface SpecificationsPrevious working titles: Central Metadata Catalog, Metadata HubBackground, motivation, contextThe project was introduced in July 2020 to provide initial information to the Analyics team on how they could deliver metadata information for lineage purposes to Informatica Enterprise Data Catalog. The solution should be independent of Informatica EDC however, as in the future Informatica EDC will be replaced by an overall, end-to-end metadata management solution.Hence, a few interface descriptions were needed and this Git repository stores and maintains them.NOTE: We are talking about Design-Time Metadata, not about operational metadata.In the json schemas you will e.g. find 'physical entity', which might be a file. The file name property will then be technical, but still excluding any operational parts.Example Physical EntityThe actual filename in an interface is customer_info.20200706-095200.txt.
In the metadata we will expect "customer_info" as technical entity name.NOTE: We require operational metadata to deliver the design-time metadata it links to.##Table of contentsThis README: installing and testing your installationInUSAGE.md:More about the Metadata Registry interfaces;The configuration explained;For more information about the authors, getting in touch and contributing, seeCONTRIBUTING.md;SeeCHANGELOG.mdfor an overview of versions of the Metadata Registry Interfaces;Finally, seeTODO.mdfor an overview of known issues (always good to be aware of these), ideas and backlogs, and any other stuff we have on the list.NOTE: this is the first iteration of the documentation, explaining the basics of the interfaces. Going forward we will build up a full fledged manual with many more examples and references. Your feedback is valuable!InstallationThe python script in this repository verifies sample json files against the json schemas.
It was built for Python 3.6.# Clone repository
git clone https://github.com/jacbeekers/metadata-registry-interface-specifications
cd metadata-registry-interface-specifications

# Create a virtualenv
python3 -m venv venv
# Linux/MacOS:
source ./venv/bin/activate
# Windows:
venv\Scripts\activate

# Enable AAB proxy (optional)
export https_proxy=<some_proxy>:8080

# Install package requirements
pip3 install -r requirements.txtTestingThe unit test python script can be run from the command line or from PyCharm.That's it! Read on inUSAGE.mdto learn more, checkCONTRIBUTING.mdto get in touch andTODO.mdto see a list of known issues.
Package: metadata-to-db
DICOM Directory to PostgreSQL DBHave you ever gotten a DICOM dataset from the internet in the form of a folder with a bunch of DCM files in it? I did recently and wanted to get an idea of the data that was housed in all of these DCM files, so I wrote this small tool that will extract all of the the DICOM elements you're interested in from all of the DCM files in the directory and it will put the data into a PostgreSQL DB table so you can indirectly query the DICOM header data.