Saravanan666/pypi-org huggingface dataset:
Package: microbiome-toolbox
DashboardMicrobiome ToolboxMicrobiome toolbox is a collection of tools and methods for microbiome data and it includes data analysis and exploration, data preparation, microbiome trajectory modeling, outlier discovery and intervention. Our toolbox encompasses most of the common machine learning algorithms that exist in different packages.Features:Data analysis and exploration of microbiota dataData preparationReference vs. non-reference data analysisLog-ratios data transformationMicrobiome trajectoryBoxplot with timeIntervention simulation.InstallationThe microbiome toolbox has aPyPi packageavailable.# create environmentcondaenvcreate-fenvironment.yml# activate environmentcondaactivatemicrobiome# install microbiome toolboxpipinstallmicrobiome-toolbox--userRun dashboard locally (on your computer)After you successfully installed the microbiome-toolbox and activated the environment, just execute the following commands:# set up the development environment (on Linux)sourcewebapp/environment/.evv.development# run the serverpythonwebapp/index.pyThe only step that differs for Windows is that you should modify the environment variables with values indicated in filewebapp/environment/.evv.development.
After that, you can run the server on Windows.ExamplesFor the toolbox usage, checkout the notebooks:1. Mouse dataset2. Mouse trajectory3. Human infants dataset4. Human infants trajectoryIssuesIf you notice any issues, please report them atGithub issues.LicenceThe project is licensed under theMIT license.AuthorsJelena Banjac,Shaillay Kumar Dogra,Norbert SprengerCitationThe code in this repository is released under the terms of theMIT license. Please cite our paper if you use it.BibTeX citation style:@article{microbiome_toolbox,
  author = {Banjac, Jelena and Sprenger, Norbert and Dogra, Shaillay Kumar},
  title = {Microbiome Toolbox: Methodological approaches to derive and visualize microbiome trajectories},
  elocation-id = {2022.02.14.479826},
  year = {2022},
  doi = {10.1101/2022.02.14.479826},
  publisher = {Cold Spring Harbor Laboratory},
  URL = {https://www.biorxiv.org/content/early/2022/02/16/2022.02.14.479826},
  eprint = {https://www.biorxiv.org/content/early/2022/02/16/2022.02.14.479826.full.pdf},
  journal = {bioRxiv}
}APA citation style:Banjac J, Sprenger N, Dogra SK. 2022. Microbiome Toolbox: Methodological approaches to derive and visualize microbiome trajectories. bioRxiv doi: 10.1101/2022.02.14.479826
https://biorxiv.org/cgi/content/short/2022.02.14.479826v1
Package: microbitdongle
AboutMicrobitdongle allows you to communicate with a micro:bit over serial.Installation / UsageTo install typepip install microbitdongleinto a terminal.Here is some example codefrommicrobitdongleimportDonglemb=Dongle(debug=True)# debug=False by default. Shows useful pairing informationwhileTrue:data=mb.recv()print(data)you can also send data to the micro:bit usinmb.send(“display.scroll(‘hi’)r”)
Package: microbit-stubs
microbit-stubs Python LibraryA Python library providing stubs for micro:bit modules, enabling code completion and static analysis in integrated development environments (IDEs).OverviewThis library contains type hints (stubs) for the micro:bit modules, allowing developers to benefit from code completion, type checking, and static analysis in their Python projects that involve micro:bit programming. These stubs are compatible with popular Python IDEs like VSCode, PyCharm, and others.FeaturesType Hints for micro:bit Modules: Comprehensive type hints for various micro:bit modules, enhancing code readability and developer productivity.IDE Compatibility: Works seamlessly with major Python IDEs, providing an improved development experience for micro:bit projects.Easy Integration: Simply install the library using pip, and your IDE should automatically recognize and utilize the provided stubs.Installationpipinstallmicrobit-stubsUsageOnce the library is installed, you can start using it in your micro:bit Python projects. Your IDE should automatically pick up the stubs and provide enhanced code completion and type checking.frommicrobitimport*# Now, your IDE should provide code completion for micro:bit modules.display.show(Image.HAPPY)sleep(1000)display.clear()ContributingWe welcome contributions to enhance and expand the microbit-stubs library. If you find any issues or have suggestions for improvement, please open an issue or submit a pull request.LicenseThis project is licensed under the MIT License - see the LICENSE file for details.
Package: microblocks
microblocksMicroBlocks and Python Communication with Messages.Installpython -m pip install microblocksUsagefrom microblocks import MessageFeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.4.0 (2024-02-03)0.3.0 (2024-02-02)0.2.0 (2024-01-07)0.1.1 (2023-12-26)0.1.0 (2023-12-25)0.0.3 (2023-12-23)0.0.2 (2022-11-29)0.0.1 (2022-10-28)First release on PyPI.
Package: microblocks-messaging-library
microblocks_messaging_libraryMicroBlocks and Python Communication with Messages.Installpython -m pip install microblocks_messaging_libraryUsagefrom microblocks_messaging_library import MicroblocksMessageFeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.2.0 (2024-01-07)0.1.1 (2023-12-26)0.1.0 (2023-12-25)0.0.3 (2023-12-23)0.0.2 (2022-11-29)0.0.1 (2022-10-28)First release on PyPI.
Package: microblocks-wifi-radio
WiFi RadioThis package works withMicroBlocksWiFi Radio library.Installpip install microblocks_wifi_radioUsageimport time
from microblocks_wifi_radio import Radio
r = Radio()
r.send_number(123)
time.sleep(1)
r.send_string("hello")
time.sleep(1)
r.send_pair("light", 10)

while True:
    time.sleep(0.01)
    if r.message_received():
        print(r.last_number)
        print(r.last_string)MicroBlocks DemoNoteMost code is written by GPT4:GPT4 translated the MicroBlocks code
Package: microblog-git
Python renderer for git microblogsThis repository contains Python library that can be used to read and rendermicroblogs based on git commit history.License and copyrightCopyright 2022 Vitaly PotyarkinLicensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
Package: microblog-server
Microblog serverPython backend for a low-volume personal microblog.Input server (Telegram bot) waits for user to post new microblog entries and
saves them to storage (git repo). Entries can be fetched from storage via
provided Python library. There is also a plugin for Pelican to render
microblog entries on a static web site.Input server and storage engine should be easy to replace or add new
implementations in future.InstallationPython package is published at PyPI:https://pypi.org/project/microblog-server/Install withpip install microblog-serverMake sure thatgitis available in $PATHReady to goDocker imageis also availableUsageRunning input serverCommandline entrypoint:microblogConfiguration is done via environment variables:MICROBLOG_STORAGE: Path to a local checkout of git repository that
stores the microblogMICROBLOG_TOKEN: Telegram bot tokenMICROBLOG_USERS: Comma-separated list of Telegram accounts allowed to
interact with the botUsing Python library to read microblog from storageSee thesource codeRendering static web siteSeePelican docsfor general information on using static site generator.Plugin configuration:# pelicanconf.pyimportmicroblog.pelicanimportmicroblog.storagePLUGINS=[microblog.pelican,]MICROBLOG=microblog.storage.GitStorage('./path/to/local/copy/of/git/repo/')Your theme is expected to provide the following templates:microsfor paginated microblog index
(example)microfor individual microblog entries
(example)Checkplugin sourcefor further information.
See author's siteconfigurationfor further examples.License and copyrightCopyright 2022 Vitaly PotyarkinLicensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: microbot
CI:PyPI:Docs:Connect instant messaging bots to your APIs.The idea is to use it as microservice to host messaging bots leaving the application model into current APIs.DocumentationThe full documentation is athttps://microbot.readthedocs.org.QuickstartInstall microbot:pip install microbotThen use it in a project:import microbotFeaturesTelegram, Kik and Facebook Messenger botsMessage handling definition with regex, as django urls.HTTP methods: GET/POST/PUT/DELETE/PATCHText responses and keyboards with Jinja2 templatesChat State handlingAsynchronous processing of messagesMedia messages not supportedRunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install -r requirements/test.txt
(myenv) $ make test
(myenv) $ make test-allHistory0.1.0 (2016-03-07)First release on PyPI.
Package: microboxlabs-auth-manager
Microboxlabs Auth Manager SDK for Python 3This SDK provides a set of tools to interact and manage authentication with Microboxlabs services using Python 3.InstallationUsing pip:You can install the SDK from PyPI usingpip:pipinstallmicroboxlabs-auth-managerUsing Poetry:If you're using Poetry for your project, you can add it as a dependency:poetryaddmicroboxlabs-auth-managerUsageTo use the SDK in your Python projects:frommicroboxlabs_auth_managerimportAuthToken# Initialization with your client detailsauth=AuthToken(client_id="YOUR_CLIENT_ID",client_secret="YOUR_CLIENT_SECRET",audience="https://api.microboxlabs.com/v1",grant_type="client_credentials")# Get a new access tokenaccess_token=auth.get_token()DevelopmentFor development purposes, you'll want to clone the repository and set up using Poetry:# Clone the repositorygitclonehttps://github.com/microboxlabs/auth-manager.gitcdauth-manager# Install the SDK dependencies for developmentpoetryinstallRunning TestsEnsure you have the development dependencies installed:# Run tests using unittest (or your preferred testing tool)poetryrunpython-munittestdiscovertests# OR if you're using pytestpoetryrunpytestFeaturesSeamless authentication with Microboxlabs services.Token management: acquire, refresh, and validate tokens.DocumentationRefer to theofficial documentationfor detailed usage and API references.ContributingPull requests are welcome! For major changes, please open an issue first to discuss what you'd like to change.LicenseMIT
Package: microbuild
Calum J. Eadie (www.calumjeadie.com)FeaturesReally quick to learn.Manages dependancies between tasks.Automatically generates a command line interface.Related projectsCheck outpynt, microbuild’s beefier younger brother.Raghunandan Raohas extended microbuild, adding features including:Rake style parameter passing to tasks.Running tasks by typing the first few characters.Breaking up script into modules.InstallationYou can install microbuild from the Python Package Index (PyPI) or from source.Using pip:$ pip install microbuildUsing easy_install:$ easy_install microbuildExampleThe build script is written in pure Python and microbuild takes care of managing
any dependancies between tasks and generating a command line interface.Tasks are just regular Python functions marked with the@task()decorator. Dependancies
are specified with@task()too. Tasks can be ignored with the@ignoredecorator.After defining all tasksbuild(sys.modules[__name__],sys.argv[1:])is called to
run the build.# example.py
import sys
from microbuild.microbuild import task,ignore,build

@task()
def clean():
    """Clean build directory."""
    print "Cleaning build directory..."

@task(clean)
def html():
    """Generate HTML."""
    print "Generating HTML..."

@ignore
@task(clean)
def images():
    """Prepare images."""
    print "Preparing images..."

@task(html,images)
def android():
    """Package Android app."""
    print "Packaging android app..."

if __name__ == "__main__":
    build(sys.modules[__name__],sys.argv[1:])The command line interface and help is automatically generated. Task descriptions
are extracted from function docstrings.$ ./example.py -h
usage: example.py [-h] task

positional arguments:
  task        perform specified task and all it's dependancies

optional arguments:
  -h, --help  show this help message and exit

tasks:
  android     Package Android app.
  clean       Clean build directory.
  html        Generate HTML.
  images      Prepare images.Dependancies between tasks are taken care of too.$ ./example.py android
[ example.py - Starting task "clean" ]
Cleaning build directory...
[ example.py - Completed task "clean" ]
[ example.py - Starting task "html" ]
Generating HTML...
[ example.py - Completed task "html" ]
[ example.py - Ignoring task "images" ]
[ example.py - Starting task "android" ]
Packaging android app...
[ example.py - Completed task "android" ]Contributingmicrobuild is hosted athttps://github.com/CalumJEadie/microbuildand contributions are
very welcome.epydocis used for documentation generation andunittestfor tests.Runbuild.py apidocto generate documentation andbuild.py testto run all unit
tests.Licensemicrobuild is licensed under a MIT license. SeeLICENSE.txt.Changes0.3.3 - 26/03/2013Improved README documentation.0.3.1,0.3.2 - 15/12/2012Improved README documentation.0.3.0 - 18/09/2012Fixed bug in logging. No longer modifies root logger.Added ignore functionality.Extended API documentation.0.2.0 - 29/08/2012Added progress tracking output.Added handling of exceptions within tasks.0.1.0 - 28/08/2012Initial release.Added management of dependancies between tasks.Added automatic generation of command line interface.
Package: microcdt
The purpose ofmicrocdtis to be the smallest practical client
library for accessing Cloudant/CouchDB databases. It’s neither fully
featured, nor complete in its API surface cover (nor is it intended to
be).It caters for the most basic operations, such as creating and deleting
databases, reading, creating, deleting, and updating documents, and
listing all documents in a database.It also has rudimentary support for bulk operations.The Cloudant class subclassesrequests.Session, so any API endpoint
not implemented directly can always be called usingCloudant.get|put|post|request.ExamplesfrommicrocdtimportCloudantdb='mydatabase'cdt=Cloudant('https://account.cloudant.com')cdt.auth=(USERNAME,PASSWORD)cdt.create_database(db)result=cdt.create_doc(db,{'name':'adam'})cdt.delete_database(db)
Package: micro-center-price-monitor
Micro Center Scraper Using Beautiful SoupTable of ContentsProject DescriptionHow to UsePackages UsedInstallationOther RequirementsTo Do ListProject DescriptionThis is a simple Python web scraper to monitor prices on Micro Center's online store for a product you may be interested in.How to Use:Upon running the program: there will be a prompt to provide a product to search:Enter the name of the product and hit Return.There will be a list of results with corresponding index values. Provide the index value for the product you want to monitor, and hit Return.Enter the price threshold you wish to receive a notification for and hit Return. The program will loop continuously until your product meets or goes below expected price and an email notification will be sent.Packages Usedbs4: version 0.0.1beautifulsoup4: version 4.7.1requests: version 2.22.0lxml: version 4.3.4InstallationInstall micro-center-price-monitor with pip:pip install micro-center-price-monitorOther RequirementsYou will need a Gmail Account set up with "Allowing less secure apps to access your account" enabled. This is not recommended for a user's main Gmail account. Using a burner gmail account is recommended in this instance.Include login info in System User Variables:"EMAIL_USER" -> set to gmail address"EMAIL_PASS" -> set to gmail passwordTO-DO LIST:Inclusion of pages 2..n for search results longer than 1 page.
Package: micro-ci
Micro-CIMicro-CIis a tiny package that allow you to run entire continuous integration
(CI) pipelines locally, without having to run all commands manually or
maintaining separate scripts for it.:warning: This project is still inalphastage. This means that interfaces
might change more often than expected. If you have any kind of issue, please
drop me a line:edgar.klenske@gauss-ml.com.IntroductionHave you ever pushed to a git repository, just to see one component of the CI
pipeline fail? The next time you runpylint,mypy,flake8and all the
other tools manually before pushing changes. Maybe you have created a script. Or
you even set up pre-commit hooks to run things automatically. But once something
changes in the CI pipeline, you have to update your pre-commit hooks again.
That's a waste of time!Micro-CI reads the GitLab CI configuration file.gitlab-ci.ymland lets you
run all stages with one command. Therefore, your local dry-run is always
consistent with the "official" CI pipeline.Getting StartedYou can installMicro-CIwith PIP easily:pipinstallmicro-ciFrom now on, you can just runmciin the folder where your.gitlab-ci.ymlfile is located.mciruns in the contextmerge_request, so that all those stages should be
executed that are run in a merge request pipeline.
Package: micro-client
Python 3 resolver forgo-microgrpc services.Installationpipinstallmicro-clientCompilingMake sure you havethe needed protobuf and
plugins.Notes: * Make sure you have the python packagegrpcio-toolsinstalled!PATH=$PATH:$GOBIN_PATHprotoc-I=$SOURCE_OF_MICRO_PROJECT--proto_path=$GOPATH/src:.--python_out=plugins=micro,grpc:.$PATH_TO_PROTO_FILEpython-mgrpc_tools.protoc-I=$SOURCE_OF_MICRO_PROJECT--python_out=.--grpc_python_out=.$PATH_TO_PROTO_FILEEtcdfrommicro_client.registryimportEtcdRegistry,EtcdClientfrommicro_client.commonimportServicesetcd_client=EtcdClient(host='localhost',port=2379)prefix="/micro/registry/"s=Services(EtcdRegistry(etcd_client,prefix))Consulimportrequestsfrommicro_client.registry.consulregistryimportRegistryfrommicro_client.commonimportServicess=Services('http://127.0.0.1:8500/v1',session=requests.Session()))Use it!# Import the stub and grpc structures for usefromsome_pb2_grpcimportSomeStubfromsome_pb2importInput,Structures# Get the stubstub=s.insecure('base_user_cf',SomeStub)# Call itresult=stub.SomeCall(Input(Data=1),Structures(Some="data",ID=1))# 如果 连接无法使用, reset stubstub=s.insecure('base_user_cf',SomeStub)
Package: microcosm-connexion
microcosm-connexionDescription:A python library that exposesmicrocosmfactories forconnexionConnexionis a python library that reads a open-api/swagger spec and binds methods for a class to the spec.
This project provides the glue betweenmicrocosmprojects andconnexion. It provides the following componentsConnexion: An instance of connexionflask: An instance of flask created by connexionapp: Same as flask instance.postgress_session_factory: Binds the Postgres SQLAlchemy session context to Flaskconnexion_error_handler: An instance of the ConnexionErrorHandler used for serializing errorsconfigure_connexion_error_handler: Binds ConnexionErrorHandler to flask's generic error handler mechanism.The reason for providing flask and app is to make sure that connexion's version of flask overrides [microcosm-flask]'s
app.Note: Acookiecutteris created to make it easy for app developers to quickly start building APIs.
Package: microcosm-flask
microcosm-flaskOpinionated Flask services.ConventionsClassify API endpoints according to an enumerated set of operations with well-defined naming conventionsHandle errors consistently using a top-level error and nested sub-errrorsHandle UUIDs as route path keysProtect endpoints with basic authUse HAL JSON links to related resources to each otherUse Swagger to publish endpoints for interoperabilityAutomate generation of endpoints according to conventions:A health check API endpoint exposes service healthRESTful endpoints provide CRUD operations on resourcesRESTful endpoints allows one resource to be related to anotherAPI discovery endpoints allow resource data to be discovered/spideredSwagger endpoints allow endpoint integration to be automatedSetupCreate a virtualenvmkvirtualenv microcosm-flaskInstall dependenciespip install -U -e .TestsRun the testspytestLintingLint the code:NAME=microcosm_flask./entrypoint.shlintNAME=microcosm_flask./entrypoint.shtypehintingConfigurationThe object graph'sdebugandtestingflags are propagated to the Flask application
Package: microcosm-flask2
microcosm-flaskOpinionated Flask services.ConventionsClassify API endpoints according to an enumerated set of operations with well-defined naming conventionsHandle errors consistently using a top-level error and nested sub-errrorsHandle UUIDs as route path keysProtect endpoints with basic authUse HAL JSON links to related resources to each otherUse Swagger to publish endpoints for interoperabilityAutomate generation of endpoints according to conventions:A health check API endpoint exposes service healthRESTful endpoints provide CRUD operations on resourcesRESTful endpoints allows one resource to be related to anotherAPI discovery endpoints allow resource data to be discovered/spideredSwagger endpoints allow endpoint integration to be automatedSetupCreate a virtualenvmkvirtualenv microcosm-flaskInstall dependenciespip install -U -e .TestsRun the testspython setup.py nosetestsConfigurationThe object graph'sdebugandtestingflags are propagated to the Flask application
Package: microcosm-neo4j
# microcosm-neo4jOpinionated persistence with Neo4J.## TestingUnit-tests require a running Neo4j instance. To run locally, can use the included Docker compose files:$ docker-compose up
$ nosetestsAs of the time of this writing, we test against Neo4J 3.5.5, which is the same version we use on our live environments via GrapheneDB. Always check the Dockerfile for the version of neo4j server we’re using if you suspect version incompatability issues when running unit-tests.