Saravanan666/pypi-org huggingface dataset:
Package: microschc
microSCHCIn a nutshellImplementation in microPython of SCHC as specified in RFC 8724 [1].LicenseMIT License, Copyright (c) 2022 Orange, by Quentin LampinInstalling microSCHCReleases of microSCHC are available on PyPI. To install microSCHC, runpipinstallmicroschcLatest (pre-release) microSCHC versions can be built from source usinghatchand installed using the wheel (.whl) file generated in thedist/folder.build:hatchbuild-twheelinstallation:pipinstalldist/microschc-<version>-py3-none-any.whlmicroSCHC, developpement planmicroSCHC aims at implementing the SCHC Compression/Decompression (C/D) and Fragmentation/Reassembly (F/R) routines described in RFC 8724 [1].The initial focus of this effort is on the Compression/Decompression (C/D) routines and parsers for typical IoT protocol stacks, i.e. based
on IPv6 [2], UDP [3], CoAP [4], lwM2M.Current features:ParsersIPv4IPv6UDPCoAP (partial test coverage: options missing)CoAP over UDP over IPv6 stack parserlwM2M ( when not using CoAP options, i.e. CoAP payloads) --> postponed to after full SCHC C/D implementationMatching Operators (MO)equalignoreMSB(x)match-mappingCompression/Decompression Actions (CDA)Compressionnot-sentvalue-sentmapping-sentLSBcompute-* (e.g. UDP-checksum)devIIDAppIIDDecompression counterpartsnot-sentvalue-sentmapping-sentLSB[-] compute-* (e.g. UDP-checksum)UDP ChecksumUDP LengthIPv6 Payload LengthIPv4 Payload LengthdevIIDAppIIDRulesrule data modelrule matching algorithmYANG model interpreterCompressionfield (left-)packetfield residues concatenationlength of variable length field encodingpacket compressionContext ManagementDefinition & implementation of custom SCHC Context (not specified in RFCs)[1] "RFC 8724 SCHC: Generic Framework for Static Context Header Compression and Fragmentation" , A. Minaburo et al.[2] "RFC 8200 Internet Protocol, Version 6 (IPv6) Specification, S. Deering et al."[3] "RFC 768 User Datagram Protocol, J. Postel"[4] "RFC 7252 The Constrained Application Protocol (CoAP), Z. Shelby et al."
Package: microschema
MicroSchemaExample:>>> import microschema
>>> schema = {
...     'username': {'type': str, 'required': True},
...     'score': {'type': int},
... }
>>> data = {
...     'username': 'foobar',
...     'score': 10000,
... }
>>> print(microschema.validate(schema, data))Python CompatibilityPython 2.7 and 3.3+ are supported.
Package: microscope
Python’smicroscopepackage is a free and open source library for:control of local and remote microscope devices;aggregation of microscope devices into complex microscopes;automate microscope experiments with hardware triggers.It is aimed at those that are building their own microscopes or want
programmatic control for microscope experiments.  More details can be
found in the paperPython-Microscope: High performance control of
arbitrarily complex and scalable bespoke microscopesand
in theonline documentation.Python Microscope source distribution are available inPyPIand can be easily
installed withpip:pip install microscopeAlternatively, the development sources are available ongithub.This package doesnotprovide a graphical user interface that a
typical microscope user would expect.  Instead, it provides the
foundation over which such interfaces can be built.  For a microscope
graphical user interface in Python consider usingMicroscope-Cockpit.
Package: microscope-automation
Microscope Automation.. image::https://github.com/aics-int/microscope_automation/workflows/Build%20Master/badge.svg:height: 30
:target:https://github.com/aics-int/microscope_automation/actions:alt: Build Status.. image::https://github.com/aics-int/microscope_automation/workflows/Documentation/badge.svg:height: 30
:target:https://aics-int.github.io/microscope_automation:alt: Documentation.. image::https://codecov.io/gh/aics-int/microscope_automation/branch/master/graph/badge.svg:height: 30
:target:https://codecov.io/gh/aics-int/microscope_automation:alt: Code CoverageAutomation software for a variety of popular microscopes, such as Zeiss and 3i.InstallationTo install the ZIP Version:Copy the zip from thelatest release <https://github.com/aics-int/microscope_automation/releases/>_For ZEN systems, runExport_ZEN_COM_Objects.bat <https://github.com/aics-int/microscope_automation/blob/master/scripts/Export_ZEN_COM_Objects.bat>_a. You may have to run as an administrator for it to work properly.Runmicroscope_automation.exefrom inside the unzipped folder.You can also use PyPI as follows:Stable Release:pip install microscope_automationDevelopment Head:pip install git+https://github.com/aics-int/microscope_automation.gitComplete installation instructions availablehere <https://aics-int.github.io/microscope_automation/installation.html/>_.DevelopmentSeeCONTRIBUTING <https://github.com/aics-int/microscope_automation/blob/master/CONTRIBUTING.rst/>_
for information related to developing the code.The Four Commands You Need To Knowpip install -e .[dev]This will install your package in editable mode with all the required development
dependencies (i.e.tox).make buildThis will runtoxwhich will run all your tests in both Python 3.7
and Python 3.8 as well as linting your code.make cleanThis will clean up various Python and build generated files so that you can ensure
that you are working in a clean environment.make docsThis will generate and launch a web browser to view the most up-to-date
documentation for your Python package.Legal DocumentsLICENSE <https://github.com/aics-int/microscope_automation/blob/master/LICENSE.txt/>_CONTRIBUTING <https://github.com/aics-int/microscope_automation/blob/master/CONTRIBUTING.rst/>_
Package: microscope-cockpit
Microscope-CockpitCockpit is a microscope graphical user interface.  It is a flexible
and easy to extend platform aimed at life scientists using bespoke
microscopes.  More detailed information is available:in theOnline documentationon theMicron Oxford websitein the recently publishedpaperMain FeaturesEasy to use and extend by life scientists:Cockpit is completely
written in Python and meant to be extended by the user.Independent of the actual devices being used:Cockpit uses
Python’sMicroscope packageto control the devices.  The graphical interface and experiments
automatically adjust to the existing devices.Very fast device control and time precision:During experiments,
devices are controlled via hardware signals.Cross Platform:Cockpit runs on GNU/Linux, Mac, and Windows.FOSS:Cockpit is free and open source software, released under
the GPL.The User InterfaceThe user interface is made up of a number of windows with the main
ones shown below.CitationIf you find this project useful, please cite:Phillips MA, Susano Pinto DM, Hall Net al. Microscope-Cockpit:
Python-based bespoke microscopy for bio-medical science. Wellcome
Open Res 2021,6:76
(https://doi.org/10.12688/wellcomeopenres.16610.1)
Package: microscopemetrics
microscope-metricsmicroscope-metrics is a Python library to control microscope quality based on standardized samplesDocumentationDocumentationRelatedHere are some related projectsAwesome READMEInstallationIf you just want to use microscope-metrics you may just install microscope-metrics with pippipinstallmicroscopemetricsFor development we usepoetryUsage/ExamplesimportComponentfrom'my-project'functionApp(){return<Component/>}Running TestsTo run tests, use pytestpytesttests
Package: microscopemetrics-schema
microscopemetrics-schemaA schema for microscope-metrics, a python package for microscope QCWebsitehttps://MontpellierRessourcesImagerie.github.io/microscopemetrics-schemaRepository Structureexamples/- example dataproject/- project files (do not edit these)src/- source files (edit these)microscopemetrics_schemaschema-- LinkML schema
(edit this)datamodel-- generated
Python datamodeltests/- Python testsDeveloper DocumentationUse the `make` command to generate project artefacts:make all: make everythingmake deploy: deploys siteCreditsThis project was made withlinkml-project-cookiecutter.
Package: microscopestitching
OverviewThis software aims to be a reliable way to stitch your microscope
images. To get good results, a couple of assumptions should be true
about your dataset:images are regular spacedimages are of same sizeside by side images have translation only in one dimension(if not, check your scanning mirror rotation)scale in edge of images are constantInstallationInstall usingpip…pipinstallmicroscopestitchingExamplefrommicroscopestitchingimportstitchfromskimage.ioimportimsaveimages=[]foriinrange(50):row=i//10col=i%10images.append(('%d.png'%i,row,col))merged=stitch(images)imsave('merged.png',merged)See alsonotebook
examples.API referenceAPI reference is athttp://microscopestitching.rtfd.org.DevelopmentInstall dependencies and link development version of microscopestitching
to pip:gitclonehttps://github.com/arve0/microscopestitchingcdmicroscopestitchingpipinstall-rrequirements.txt# install dependencies and microscopestitching-packageTestingtoxBuild documentation locallyTo build the documentation:pipinstall-rdocs/requirements.txtmakedocs
Package: microscopy-portfolio
Microscopy PortfolioA helper package to download example datasets used in various publications by the Jug lab, including data featured in N2V, P(P)N2V, DivNoising, HDN, EmbedSeg, etc.The complete list of datasets can be foundhere.InstallationTo install the portfolio in your conda environment, simply usepip:$pipinstallmicroscopy-portfolioUsageFollow theexample notebookfor details on how to use the package.The portfolio can be instantiated as follow:frommicroscopy_portfolioimportPortfolioportfolio=Portfolio()You can explore the different datasets easily:print(portfolio)print(portfolio.denoising)print(portfolio.denoising.N2V_SEM)Finally, you can download the dataset of your choice:frompathlibimportPathdata_path=Path('data')portfolio.denoising.N2V_SEM.download(data_path)Add a dataset to the repositoryTo add a dataset, subclass aPortfolioEntryand enter the following information
(preferably in one of the current categories, e.g.denoising_datasets.py):classMyDataset(PortfolioEntry):def__init__(self)->None:super().__init__(name="MyDataset",url="https://url.to.myfile/MyFile.zip",file_name="MyFile.zip",md5_hash="953a815333805a423b7019bd16cc3341",description="Description of the dataset.",license="CC-BY",citation="Citation of the dataset',files={"/folder/in/the/zip":["file1.tif","file2.tif"],# folder can be "."},size=13.0,# size in MB)To obtain md5 hash of your file, you can run the following code:frompathlibimportPathimporthashlibfile_path=Path("path/to/myfile.zip")hashlib.md5(open(file_path,"rb").read()).hexdigest()Likewise, to get the size in MB of your file:importosos.path.getsize(file_path)/1024/1024Finally, add the file class to one of the categories (e.g. denoising) inportfolio.py:classDenoising(IterablePortfolio):def__init__(self)->None:self._N2V_BSD68=N2V_BSD68()self._N2V_SEM=N2V_SEM()self._N2V_RGB=N2V_RGB()self._flywing=Flywing()# add your dataset as a private attributeself._myDataset=MyDataset()[...]# and add a public getter@propertydefMyDataset(self)->MyDataset:returnself._myDataset
Package: microsearch
A small search library.Primarily intended to be a learning tool to teach the fundamentals of search.Useful for embedding into Python apps where you don’t want/need something
as complex as Lucene.Part of my (upcoming) 2012 PyCon talk -https://us.pycon.org/2012/schedule/presentation/66/RequirementsPython 2.5+ or Python 3.2+(Optional) simplejson(Optional) unittest2 (Python 2.5 - for runnning the tests)UsageExample:import microsearch

# Create an instance, pointing it to where the data should be stored.
ms = microsearch.Microsearch('/tmp/microsearch')

# Index some data.
ms.index('email_1', {'text': "Peter,\n\nI'm going to need those TPS reports on my desk first thing tomorrow! And clean up your desk!\n\nLumbergh"})
ms.index('email_2', {'text': 'Everyone,\n\nM-m-m-m-my red stapler has gone missing. H-h-has a-an-anyone seen it?\n\nMilton'})
ms.index('email_3', {'text': "Peter,\n\nYeah, I'm going to need you to come in on Saturday. Don't forget those reports.\n\nLumbergh"})
ms.index('email_4', {'text': 'How do you feel about becoming Management?\n\nThe Bobs'})

# Search on it.
ms.search('Peter')
ms.search('tps report')ShortcomingsThis library is meant to help others learn. While it has full test coverage,
it may not be suitable for production use. Reasons you may not want to use it
in Real Code(tm):No concurrency supportTries to work atomically with filesBut there are no locksSo it’s possible for writes to overlap between processesMaybe thread-safe?Pretty much everything is on an instanceBut I haven’t tested it extensively with threadingNo support for deleting documentsIf an existing document changes or gets deleted, stale data will be left
in the indexA workaround would be blowing away the index directory, moving the docs out
and reindexing them :/Only n-grams are supportedBecause writing a full Porter or Snowball stemmer is beyond the needs
of this libraryNo clue on performance at scaleThis is a proof-of-concept & learning tool,notLucene!With a 2011 MBP on the first 1.2K docs of the Enron corpus:Indexing is pretty slow at ~1 document per secondSearch is pretty fast at ~0.007 sec per queryRAM never exceeded 15Mb when indexing, 10Mb when searchingScript in the source repo asenron_bench.py.Running TestsWith a source checkout, run:In Python 2:python -m unittest2 testsIn Python 3:python -m unittest testsTests should be passing at all times under both Python 2.7 & Python 3.2.ContributionsIf you wish to contribute to improvingmicrosearch, the code you submit
must:Be your own work & BSD-licensedInclude a working fix/featureFollow the existing style of the codebaseInclude passing test coverage of the new codeIf it’s user-facing, must include documentationOther submissions are welcome, but won’t get merged until all of these
requirements are met.author:Daniel Lindsley <daniel@toastdriven.com>date:2011/02/22
Package: microsecrets
Microsecretsis a secrets distribution tool powered by Amazon S3 and Amazon
KMS. It provides a bare-bones approach to passing credentials securely in an
Amazon Web Services environment. Credentials are uploaded to S3 and encrypted
at rest by KMS. They can then be passed to programs through environment
variables.Installation$pipinstallmicrosecretsUsageSetupCreate the S3 bucket you’ll use for secrets storage. You may want one bucket
per organization, such asexample.com-microsecrets.Create one KMS master key for each service that will be using microsecrets.
The key should by default be namedmicrosecrets-myservicefor a service
called myservice. Users uploading the credentials and systems downloading
the credentials will need privileges to encrypt/decrypt data using this key.
None of the normal users need key administration privileges.Uploading environment and filesUpload environment variable data. Environment variables may be passed as=separated pairs on stdin or in a file.NB: whitespace is stripped and
all other characters are treated literally.Or pass them as a JSON dict
with the--jsonflag.$microsecrets-upload-bexample-microsecrets-smyservice<<EOM
DB_URL=db://user:pass@example.com:123
PASSWORD=hunter2
EOMUpload a raw file. Usage is the same as uploading environment variables, but
you pass a -f LABEL to determine where to upload the file. This example
uploads a file from~/documents/train.txtwith labeltrain.txt.$microsecrets-upload-bexample-microsecrets-smyservice-ftrain.txt~/documents/train.txtDownloading files to show statusTODO: flesh out this sectionList latest versions of current files available for download$microsecrets-download-bexample-microsecrets-smyservice--listDownload the environment$microsecrets-download-bexample-microsecrets-smyserviceDownload files with the environment$microsecrets-download-bexample-microsecrets-smyservice-ftrain.txt:/tmp/train.txtRunning programs under environment with secretsRun a program with the credentials in the environment. To verify the
integrity of data in S3, you must specify the checksum of the environment
file (output by the upload tool) or whitelist specific environment
variables. Or, if integrity is not a concern, whitelist all environment
variables. The whitelist is designed to avoid accidentally allowing code
execution throughLD_PRELOADor similar, which may or may not be a
concern in your system layout.$microsecrets-with-env-bexample-microsecrets-smyservice-w'DB_URL PASSWORD'--/bin/myserverSee alsoThere is a variety of other recent work in this space that may be of interest:Confidant —https://github.com/lyft/confidantSops —https://github.com/mozilla/sopsSneaker —https://github.com/codahale/sneakerCredstash —https://github.com/fugue/credstashVault —https://github.com/hashicorp/vaultKeywhiz —https://github.com/square/keywhizLicenseThe project is in the public domain, and all contributions will also be
released in the public domain. By submitting a pull request, you are agreeing
to waive all rights to your contribution under the terms of theCC0 Public
Domain Dedication.This project constitutes an original work of the United States Government.
Package: microserial
MicroSerial is Python module for receiving data from BBC micro:bit serial port.
Simplest example:frommicroserialimportMicrobitm=Microbit()#Microbit is stream type:foriinm:print(i)Or, a bit more complex example, but does the same thing:frommicroserialimportMicrobitm=Microbit()whileTrue:print(m.readline())You can redirect Microbit to stdoutfrommicroserialimportMicrobitm=Microbit()#replaces stdoutm.replace_stio()#reads from ita=input()#return back to normalm.rstio()
Package: microservice
## Powerful REST API *microservice* on Tornado### Main goalSometimes we need to deploy microservices like messenger bots (telegram, facebook), small backends, webhooks and other.This package contains all you need to setup simple endpoint in minutes with authorization, caching, and improved security.### Features- tornado with improved basic handler for easy create REST endpoints- async non-blocking highly durable and scalable- handlers versioning (e.g. GET /**v2**/cat?color=blue)- request validation, answer containerization- poor documented, sorry :(### Under the hood- tornado 5All features below are optional- peewee / peewee_async as ORM- User and session models- oauth support- simple redis caching- sentry integration + telegram reports- prometheus monitoring### Testing1. PYTHONPATH=./microservice python test.py1. curl localhost:8001/v1/test | json_pp1. inspect test.py and enjoy### Getting startedcoming soon...
Package: microservicecryp
python3-libThe microservice-libary for python3 of cryptic-game.Pypi Seite:https://pypi.org/project/cryptic-game/Installation:$pip3installcryptic-gameQuick StartfromcrypticimportMicroServicems:MicroService=MicroService(name="echo")@ms.microservice_endpoint(path=["microservice"])defhandle(data:dict,microservice:str):print(data,microservice)return{}@ms.user_endpoint(path=["user"])defhandle(data:dict,user:str):print(data,user)return{}if__name__=='__main__':ms.run()RequirementsRequired are all modules in therequirements.txt.Test it!Your microservice will be supported by thegame-server of cryptic.Environment variableskeydefault valueSERVER_HOST127.0.0.1SERVER_PORT1239WikiVisit ourwikifor more information.
Package: microservice-maker
Projeto micro serviçoProjeto para criar micro serviços de forma mais otimizada. Para isso tem que
ter certeza que todas as dependências do da biblioteca PySide6 estejam cumpridas.PySimpleGuiTem que instalar na mão o fork do django responsável pela aplicaçãopip install git+https://github.com/victorhdcoelho/django.gitPara utilizar a biblioteca basta baixar com pip:pip install microservice-makerPara rodar a biblioteca basta escreverpython3 -m make-microserviceoumake-microserviceSiga o passo a passo e no final terá o que deseja
Package: microservice-setup
Microservice SetupOverviewMicroservice Setup is a Python-based Command-Line Interface (CLI) tool aimed to auto-generate a domain-driven, scalable, and maintainable microservices directory structure based on hexagonal architecture.FeaturesAuto-generates a clean and scalable microservices project skeletonBuilt around hexagonal architecture principlesAllows for easy customization to include user-defined modulesWorks with Python 3.9 or laterInstallationVia pippipinstallmicroservice_setupClone RepositoryClone this repository and navigate into the directory:gitclonehttps://github.com/DoMo-98/microservice_setup.gitcdmicroservice_setupUsageAfter installation, you can initialize your microservices project in one of two ways:Via pip installation:ms-initexampleVia Python module:python-msrc.mainexampleFollow the prompts to set up your project.Generated StructureWhen you runmicroservice_setup, the following directory structure will be generated:example_service/
├── app/
│   ├── adapters/
│   │   ├── controllers/
│   │   └── serializers/
│   ├── application/
│   │   ├── services/
│   │   └── use_cases/
│   ├── common/
│   │   └── constants/
│   └── domain/
│       ├── entities/
│       ├── exceptions/
│       └── interfaces/
├── config/
├── constants/
├── main.py
├── requirements/
├── templates/
└── tests/
    ├── adapters/
    │   ├── controllers/
    │   └── serializers/
    ├── application/
    │   ├── services/
    │   └── use_cases/
    ├── common/
    │   └── constants/
    └── domain/
        ├── entities/
        ├── exceptions/
        └── interfaces/This structure adheres to the principles of hexagonal architecture and DDD, providing a clear and maintainable outline for your microservice.RequirementsPython 3.9 or laterDependenciesTo be added based on your project's needs.AuthorÉric Dominguez Morales -Initial Work-EmailLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for details.
Package: microservice-template
Microservice-TemplateMicroservice-Templateis a Python module that provides a simple template class for creating microservices using the Flask web framework. This template class is designed to streamline the process of creating microservices by providing common functionality that is often repeated in microservice development.FeaturesProvides a base class,Microservice, which includes a basic Flask application setup with CORS support.Allows microservices to easily define routes and endpoints with minimal boilerplate code.Encourages best practices for microservice development, making it easier to maintain and scale microservices.UsageTo use theMicroservice-Templatein your microservice project, simply inherit from theMicroserviceclass and add your custom routes and endpoints. The template class takes care of the core setup, allowing you to focus on the specific functionality of your microservice.frommicroservice_templateimportMicroserviceclassMyMicroservice(Microservice):def__init__(self):super().__init__("my-service",5000)defcustom_route(self):# Define your custom route logic hereif__name__=='__main__':my_service=MyMicroservice()my_service.run()