Saravanan666/pypi-org huggingface dataset:
Package: micress-micpy
MicPyMicPy is a Python package to facilitateMICRESSworkflows. Whether you aim to visualize, convert, or manipulate MICRESS data, MicPy provides the necessary tools.Installationpip install micress-micpyDependenciesMicPy requires the following dependencies:Python (>= 3.9)Pandas (>= 1.1)Matplotlib (>= 3) as an optional dependency for plottingExamplesBelow are some examples demonstrating how to use MicPy.binmoduleRead one field at a timefrommicpyimportbinforfieldinbin.File("A001_Delta_Gamma.conc1"):print(field)Read all fieldsfrommicpyimportbinwithbin.File("A001_Delta_Gamma.conc1")asfile:fields=file.read()print(fields)Read a subset of fields providing a list of indicesfrommicpyimportbinwithbin.File("A001_Delta_Gamma.conc1")asfile:fields=file.read([0,1,-2,-1])print(fields)Read a subset of fields providing a condition functionfrommicpyimportbinwithbin.File("A001_Delta_Gamma.conc1")asfile:fields=file.read(lambdafield:field.time>=10andfield.time<=20)print(fields)Read fields opening and closing the file manuallyfrommicpyimportbinfile=bin.File("A001_Delta_Gamma.conc1")file.open()first_field=file.read(0)second_field=file.read(1)file.close()print(first_field,second_field)Plot a fieldfrommicpyimportbinwithbin.File("A001_Delta_Gamma.conc1")asfile:field=file[-1]fig,ax=field.plot()Plot a list of fields normalizing the datafrommicpyimportbinwithbin.File("A001_Delta_Gamma.conc1")asfile:fields=file[[0,1,-2,-1]]fig,ax=fields.plot(normalize=True,figsize=(8,8))Plot a specific plane of a fieldfrommicpyimportbinwithbin.File("A005_Grain_Growth_Misorientation_3D.korn")asfile:field=file[0]fig,ax=field.plot(plane="xy",slice=50)tabmoduleRead a tablefrommicpyimporttabtable=tab.read("A001_Delta_Gamma.TabF")Plot a tablefrommicpyimporttabtable=tab.read("A001_Delta_Gamma.TabF")fig,ax=table.plot(x=1,y=[2,3,4])Extract a subset of a tablefrommicpyimporttabtable=tab.read("A001_Delta_Gamma.TabF")table.loc[table["Fraction Phase 2 FCC_A1"]>0,["Temperature [K]","Fraction Phase 1 BCC_A2","Fraction Phase 2 FCC_A1"]]Convert a table to different file formatsfrommicpyimporttabtable=tab.read("A001_Delta_Gamma.TabF")table.to_csv("A001_Delta_Gamma.TabF.csv")table.to_excel("A001_Delta_Gamma.TabF.xlsx")table.to_json("A001_Delta_Gamma.TabF.json")
Package: microagent
The goal of this project is to facilitate the creation ofmicroservicesinteracting via asignal busand/orqueue broker.The philosophy of this project is to present a microservice as a software agent
that directly interacts only with queues and the event bus, and not with other microservices.Tool is intended for developing:distributed apps withevent-drivenarchitecturedistributed apps withdata-drivenarchitecturemulti-processors appsTool provide features:running aperiodical tasks(interval or as CRON)specification of signals (events), their sending and receiving via the bus (aioredis)description of queues, sending and receiving messages via the queue broker (aioamqp,kafka,aioredis)limitedRPCvia signal buslaunching sub-services (in the same process)launching a group of microagents (each in a separate process)mocks for bus and brokerSee MicroAgentdocumentation.classAgent(MicroAgent):@on('pre_start')asyncdefsetup(self):pass# init connections to DB, REDIS, SMTP and other services@periodic(period=5)asyncdefrefresh_cache(self):pass# do something periodicly@cron('0 */4 * * *')asyncdefsend_report(self):pass# do something by schedule# subscribe to signals (events)@receiver(signals.user_updated,signals.user_deleted)asyncdefsend_notification(self,**kwargs):# send signal (event) to busawaitself.bus.check_something.send(sender='agent',**kwargs)# message consumer from queue@consumer(queues.mailer)asyncdefsend_emails(self,**kwargs):# send message to queueawaitself.broker.statistic_collector.send(kwargs)asyncdefmain():bus=AIORedisSignalBus('redis://localhost/7')broker=AIORedisBroker('redis://localhost/7')# usage bus and broker separate from agentawaitbus.started.send('user_agent')awaitbroker.mailer(data)agent=Agent(bus=bus,broker=broker)awaitagent.start()InstallingWithaioredisbackend provide signal bus and list-based queues:pip install 'microagent[aioredis]'Withaioamqpbackend provide queues over AMQP (RabbitMQ):pip install 'microagent[amqp]'Withkafkabackend provide queues over Kafka (experemental):pip install 'microagent[kafka]'
Package: microagg1d
microagg1dA Python library which implements different techniques for optimal univariate microaggregation. The two main parameters that determine the runtime are the length n of the input array and minimal class size k. This package offers both O(n) (fast for large k) and O(kn) (fast for small k) algorithms.The code is written in Python and relies on thenumbacompiler for speed.Requirementsmicroagg1drelies onnumpyandnumbawhich currently support python 3.8-3.11.Installationmicroagg1d is available onPyPI, the Python Package Index.$pip3installmicroagg1dExample Usagefrommicroagg1dimportunivariate_microaggregationx=[5,1,1,1.1,5,1,5.1]clusters=univariate_microaggregation(x,k=3)print(clusters)# [1 0 0 0 1 0 1]# explicitly choose method / algorithmclusters2=univariate_microaggregation(x,k=3,method="wilber")print(clusters2)# [1 0 0 0 1 0 1]# choose a different cost (sae / sse / roundup / rounddown / maxdist)clusters3=univariate_microaggregation(x,k=3,cost="sae")print(clusters3)# [1 0 0 0 1 0 1]Important notice: On first import the the code is compiled once which may take about 30s. On subsequent imports this is no longer necessary and imports are almost instant.TestsTests are intests/.# Run tests$python3-mpytest.Method DetailsCurrently the package implements the following methods:"simple"[O(nk), faster for small k]"wilber"[O(n), faster for larger k]"galil_park"[O(n), fewer calls to SMAWK]"staggered"[fastest O(n)]By default, the package switches between the simple and wilber method depending on the size of k.Both methods rely on a prefix sum approach to compute the cluster cost. As the prefix sums tend to become very large quite quickly, a slightly slower but numerically more robust method is chosen by default. If your data is small, or you don't need the numeric stability then you may choose to also opt out of stable.LicenseThe code in this repository has an BSD 2-Clause "Simplified" License.SeeLICENSE.ReferencesHansen, S.L. and Mukherjee, S., 2003. A polynomial algorithm for optimal univariate microaggregation. IEEE Transactions on Knowledge and Data EngineeringWilber, R., 1988. The concave least-weight subsequence problem revisited. Journal of Algorithms, 9(3), pp.418-425.Galil, Z. and Park, K., 1989. A linear-time algorithm for concave one-dimensional dynamic programming.
Package: microagi
µAGI: Micro AI, Macro SolutionsWelcome to µAGI, where we believe in the power of specialized Artificial Intelligence. In a world that's rapidly advancing towards generalized AI systems, we stand out by focusing on the small, specific challenges that often go unnoticed.PhilosophyOur philosophy is simple: "Do one thing, and do it well." We emphasize precision, specificity, and the value of targeted solutions. We are committed to leveraging the finesse of micro-level AI to reshape how developers interact with their toolchains—one task, one solution, one revolution at a time.To read more of our inspiration see theUnix Philosophy.Our Tools: AToolsWe offer a suite of tools collectively named "ATools," each designed to handle specific tasks with unprecedented efficiency. Our first release, AGit, effortlessly translates natural language into Git commands, making it easier for developers to interact with version control systems without the hassle of learning intricate command-line syntax.ContactEmail us atcontact@microagi.dev. For bug reports, requests and testing feedback please open a Github issue in the respective respotiroy.LicenseAll our tools are open-sourced under the GPLv3 License. If you find it useful in your daily use, we'd appreciate a symoblic contribution via GitHub sponsers 😎SeeLICENSE.mdfor more details.Copyright© 2023MicroAGI, Sivan GrünbergVitakka ConsultingAll Rights Reserved.
Package: microagi-git
AGit: Git for the Pragmatic (and Slightly Lazy) DeveloperAre you tired of Git, with its command-line syntax that sounds like a half-baked mixture of Latin and Klingon? Do you find yourself in the middle of an intense coding session, only to be jolted out of the flow because you can't remember the exact sequence of characters to pluck a revision out or execute a particular operation? Has your mind ever screamed, "It's 2023, for crying out loud, not the 90s!"Well, welcome to the club! My name is Sivan, and like you, I'm a lazy (read: efficient) developer who loves to code but hates to wrestle with Git's arcane syntax.So, I created AGit: the Git whisperer, making Git a tad more civilized and a lot more human-friendly. It's a command-line assistant that translates your natural language into Git commands. Who would have thought it could be as easy as just telling Git what to do, like, in English?To start speaking the Git language without actually learning it, you'll need:Python 3.11 or higher (A magical snake, with magical powers)OpenAI API key (No less magical)How to Use Your New PowersWant to make Git do your bidding? Just whisper your command into AGit's ear:agitcomparelasttworevisionsOr:agitcheckoutabranchtoworkonthelrucachefeatureAGit will interpret your request, translate it to Git-ese, and voila! You've just manipulated the time-space coding continuum.This is ashortenedversion of the README you should probably checkouthere:)Welcome to 2023, where we make developer tools work for us, in the language we choose.
Package: microaligner
MicroAligner: image registration for large scale microscopyAutomatic, no need to manually select points of interestFast, most of internal tasks are parallelizedMemory efficient, keeps only one image page in the memory at a timeScalable, the more cores you have the faster it worksLinear and non-linear alignment, gives best results together in that orderThere are two main methods that can do alignment, and also a pipeline that can run both of them based
on parameters provided in a config file.Methods:Affine feature based registration method first finds image features usingFASTfeature finder. It detects areas with
large intensity changes. After that aDAISYfeature descriptor collects histograms of oriented gradients
for each found feature. Then the described features are matched usingFLANNbasedknnmatcher that finds
correspondence between features of reference and moving images. The matches are filtered according to the distance between the neighbours.
Finally, the coordinates of matched features are aligned usingRANSACalgorithm and the affine transformation is computed.
This method is good for aligning large linear drifts across images.Non-linear optical flow based registration usesFarnebackmethod that looks for pixels with the highest similarity in the given window.
Then for each pixel it computes a 2D vector that describes movement of the pixel from one image to the other.
This method is good for aligning of small local shifts across images.If you have uneven illumination across the image, and it affects the registration quality,
you can try to tackle that by enabling image preprocessing withdifference of Gaussians(DOG).
It will extract information about strong gradients near the edges
and discard gradual changes caused by uneven illumination.Pipeline:If images have z-planes, the script perform maximum intensity projection along the z dimension
before doing the registration, so the alignment happens only in X-Y coordinates.
The output image has OME-TIFF metadata, and dimension order TCZYX.The pipeline accepts a YAML config file. Please check config_examples folder inside this repo.Installationpip install microalignerDependenciesnumpy tifffile pandas opencv-contrib-python dask scikit-learn scikit-image pintAlso check up theenvironment.yamlfile.Example usageAs a pipelinemicroaligner config.yamlFor details about the config parameters please refer to the exampleconfig.yamlprovided in this repository.As a moduleFeature based registrationfrommicroalignerimportFeatureRegistrator,transform_img_with_tmatfreg=FeatureRegistrator()freg.ref_img=img1freg.mov_img=img2transformation_matrix=freg.register()img2_feature_reg_aligned=transform_img_with_tmat(img2,img2.shape,transformation_matrix)Optical flow based registrationfrommicroalignerimportOptFlowRegistrator,Warperofreg=OptFlowRegistrator()ofreg.ref_img=img1ofreg.mov_img=img2flow_map=ofreg.register()warper=Warper()warper.image=img2warper.flow=flow_mapimg2_optflow_reg_aligned=warper.warp()AcknowledgmentsThis package could have never been developed without thorough battle-testing byTong LiandJun Sung Park,
and guidance fromOmer Bayraktar.
Package: microarray_quantilenorm
Documentationmicroarray-quantilenorm
documentationDescriptionThis is an implementation of quantile normalization for microarray data
analysis.Usagepythonquantile_normalizationCSVmicroarray-quantilenormwill then do the following:Output a list of expression values for genes of interest in each
sample to stdout.Create a PDF and PNG file graphing the distribution for each sample
both before and after normalization.Restrictions1.) Each CSV file must contain the same gene set.2.) Each gene must be unique.Example:> ABCD1 5.675
> ABCD2 3.456
> ABCD3 5.432RequirementsMatplotlib = 1.4.3Scipy = 0.5.1Installationpip installmicroarray-quantilenorm
Package: microarviz
ArviZ (pronounced "AR-vees") is a Python package for exploratory analysis of Bayesian models.
Includes functions for posterior analysis, data storage, model checking, comparison and diagnostics.ArviZ in other languagesArviZ also has a Julia wrapper availableArviZ.jl.DocumentationThe ArviZ documentation can be found in theofficial docs.
First time users may find thequickstartto be helpful. Additional guidance can be found in theuser guide.InstallationStableArviZ is available for installation fromPyPI.
The latest stable version can be installed using pip:pip install arvizArviZ is also available throughconda-forge.conda install -c conda-forge arvizDevelopmentThe latest development version can be installed from the main branch using pip:pip install git+git://github.com/arviz-devs/arviz.gitAnother option is to clone the repository and install using git and setuptools:git clone https://github.com/arviz-devs/arviz.git
cd arviz
python setup.py installGalleryDependenciesArviZ is tested on Python 3.7, 3.8 and 3.9, and depends on NumPy, SciPy, xarray, and Matplotlib.CitationIf you use ArviZ and want to cite it please useHere is the citation in BibTeX format@article{arviz_2019,
  doi = {10.21105/joss.01143},
  url = {https://doi.org/10.21105/joss.01143},
  year = {2019},
  publisher = {The Open Journal},
  volume = {4},
  number = {33},
  pages = {1143},
  author = {Ravin Kumar and Colin Carroll and Ari Hartikainen and Osvaldo Martin},
  title = {ArviZ a unified library for exploratory analysis of Bayesian models in Python},
  journal = {Journal of Open Source Software}
}ContributionsArviZ is a community project and welcomes contributions.
Additional information can be found in theContributing ReadmeCode of ConductArviZ wishes to maintain a positive community. Additional details
can be found in theCode of ConductDonationsArviZ is a non-profit project under NumFOCUS umbrella. If you want to support ArviZ financially, you can donatehere.Sponsors
Package: microasync
Green threads and CSP for micropython.Api documentation.InstallationFor installing run:pip-micropythoninstallmicroasyncBasic usageFor basic usage you should create coroutines and start main loop.
For example, script that printsok!every ten seconds:frommicroasync.asyncimportloop,coroutine,Delay@coroutinedefmain_coroutine():whileTrue:print('ok!')yieldDelay(10)main_coroutine()loop()More examples:examples in repo;green threads on pyboard;csp on pyboard;frp on pyboard.
Package: microbar
Low-pressure bar graphs for Python.FeaturesSafe: Object is thread-safe and parameters are type-checked.Friendly: Raises human-readable errors.Tested: Package has good test coverage.Customizable: Constructor takes custom bar characters.Free software: Published under a OSI-compatible license.Compatible: Runs on multiple versions of CPython and PyPy.Convenient: Package installable from PyPI via pip.StatusInstallationpip install microbarDocumentationhttps://microbar.readthedocs.io/en/latest/TestingTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxReleasingbumpversion --new-version 0.2.0 minor
python setup.py sdist bdist_wheel uploadSee Alsocanassa/minibarfor a vertical (progress)
bar.Changelog0.1.0 (2016-09-02)First release on PyPI.0.2.0 (2016-09-02)Integrations of CI services.0.3.0 (2016-09-03)First usable version, full test suite.
Package: microbarometer
Microbarometer read/plot from PythonEasy Python program for reading and plotting SEED microbarometer data.
Uses ObsPy.Installpython -m pip install -e .If you have trouble installing PROJ.4, tryconda install cartopyUsageimportmicrobarometerasmbdata=mb.load('myfile.asc')Data formatObsPy is mostly for MiniSEED, and wasn't able to read the particular.seedfiles we had.
An alternative method is to convert SEED to SAC format:Downloadrdseed utility.
The executablerdseed.rh6.linux_64worked for me on Ubuntu as well.extract executable. For Ubuntu:tarxfrdseedv*.tar.gzrdseedv*/rdseed.rh6.linux_64
mvrdseedv*/rdseed*rdseedconvert SEED to SAC, for example to write SAC ASCII (readable by Pandas)../rdseed-fmyfile.seed-o6-dOther output formats are possible via the-ooption.NotesTo get help:./rdseed-hchannel BDO is "Bottom Pressure" in Pascals.Convert SEED to SAC (readable by ObsPy, MatSAC, etc.):./rdseed-fmyfile.seed-dList time range of data with-toption:./rdseed-fmyfile.seed-tRead SEED headers (extensive metadata):./rdseed-fmyfile.seed-s
Package: microBeesPy
Official microBees Python LibraryUsed as a wrapper dependency in the Home Assistant integration.Version0.0.1Installation>>> pip3 install microBeesPyGetting StartedGo tohttps://developers.microbees.com/dashboard/and register your developer App.
Use CLIENTID and CLIENT SECRET generated.Example basic usage>>> microBees = MicroBees("my-client-id","my-secret")
>>> token =  await microBees.login("mymicrobeesaccount@microbees.com","mypassword") //this will return the access_token
>>> bees = await microBees.getBees() // this will return the list of bees connected to mymicrobeesaccount@microbees.com
>>> cmdRes = await microBees.sendCommand(actuatorId,relayValue) //set the actuatorId to relay value (0 to off, 1 to on, 1000 to turn on for 1 second)SupportIf you find a bug, have any questions about how to use this SDK or have suggestions for improvements then feel free to
file an issue on the GitHub project pagehttps://github.com/microBeesTech/pythonSDK.License(MIT License)
Package: microbenthos
MicroBenthos is a modeling framework (in python) useful for studies of benthic
microbial systems, such as microbial mats, marine sediments, etc. It enables in
silico experiments in microbial ecophysiology and biogeochemistry through
computational simulations of geochemical processes, microbial metabolism and
mass transport physics.Free software: MIT licenseDocumentation:https://microbenthos.readthedocs.ioSource code:https://github.com/achennu/microbenthosSimulation exampleFromyoutubeFeaturesCreate microbenthic systems:Study dynamics of microbial and geochemical sedimentary processes by solving
their partial differential equations. Easily include microbial populations,
solar irradiance, anisotropic diffusion and more in your models.Scientist-friendly:Define constitutive chemical and biological processes simply as mathematical
formulae. Data is saved in open archival format.Visualize on the go:Includes visualization of modelled parameters and results that can be viewed
live, and exported to video. Progress information on simulation is also shown.Stateful simulations:Simulations can be interrupted and then resumed, allowing for interactive
inspection and time-saving.No programming required:Systems and behavior can be defined through a structured text file.Extensible:New modalities of microbial systems can be created with simple programming
around a defined structure.
Package: microbin
MicroBIN python libraryMicroBIN is a compact binary serialization format.More info about MicroBIN formatInstalling# Linuxpipinstallmicrobin# Windowspy-3-mpipinstallmicrobinUsageUse as libraryMicroBIN library provides json-like interface withload(s)anddump(s)functions.Command line utilitiesNote. For windows usepy -3 -m ...instead ofpython -m ....mbstat$ python -m microbin.mbstat -h
usage: microbin.mbstart [-h] [-V] [-s {count,size,bpo}] file

Analyze MicroBIN file

positional arguments:
  file                  MicroBIN file to analyze

options:
  -h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -s {count,size,bpo}, --sort {count,size,bpo}
                        set field to sort (default: size)

(c) NekoNekoNyan <me@neko-dev.ru>, 2023mb2json$ python -m microbin.mb2json -h
usage: microbin.mb2json [-h] [-V] [-o OUTPUT] [-m MAGIC] [-c] [-a] file

Convert MicroBIN file to json

positional arguments:
  file                  MicroBIN file to convert

options:
  -h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -o OUTPUT, --output OUTPUT
                        set output json file (default: standart output)
  -m MAGIC, --magic MAGIC
                        set application magic (default: 0000)
  -c, --compact         create compact json
  -a, --ascii           create json without any non-ascii characters

(c) NekoNekoNyan <me@neko-dev.ru>, 2023json2mb$ python -m microbin.json2mb -h
usage: microbin.json2mb [-h] [-V] [-i INPUT] [-m MAGIC] [-f {16,32,64}] file

Convert json to MicroBIN file

positional arguments:
  file                  output MicroBIN file

options:
  -h, --help            show this help message and exit
  -V, --version         show program's version number and exit
  -i INPUT, --input INPUT
                        set input json file (default: standart input)
  -m MAGIC, --magic MAGIC
                        set application magic (default: 0000)
  -f {16,32,64}, --float-size {16,32,64}
                        set size of float numbers (in bits; default: 64)

(c) NekoNekoNyan <me@neko-dev.ru>, 2023LicenseMIT License.See here for more info
Package: microbio
a minimalist Bioinformatics frameworkFor most of my use cases, extensive frameworks such as Biopython or scikit-bio are complete overkill. These frameworks are handling everything as an object (e.g. Sequences) which is certainly helpful in some cases, but often it’s just more straightforward to save the sequences as plain python strings.This framework aims at providing a bunch of modules for bioinformatics that are lightweight and super-easy to use. At the moment it is limited to some file reading and writing routines, but who knows what comes in the future ;)Installationpip install microbioContributingI will extend this project as it serves my projects. If you have useful code to add, feel free to send a pull request.Documentationhttp://microbio.readthedocs.org/