Saravanan666/pypi-org huggingface dataset:
Package: microviewer
microviewerMultiplatform 3D numpy image browser based viewer.frommicroviewerimportview,hyperviewview(numpy_image)# for gray and color imagesview(numpy_image,seg=True)# for segmentation labelsview(numpy_image,seg=True,port=8082)hyperview(image,labels)# interactive overlayuviewimage.npy.gz# view as imageuviewlabels.npy.gz--seg# view as segmentationuviewimage.npy.gzlabels.npy.gz# view image w/ overlayuviewimage.npy.gz--paint# view image w/ blank overlayVisualize 3D numpy arrays in your browser without difficult installation procedures or reformatting your data.  The code is CPU based and the image is uncompressed in memory. You're limited to images that are at most 2^31 bytes large (~2.1 GB) due to browser limitations.Features3 axis visualization of 3D images.Grayscale images with segmentation overlay.Segmentation selection with brush tools.Direct voxel painting.Save segmentation as.npyor.ckl, an advanced compresssion format.Undo/RedoSupports8-bit grayscale 3D imagescolor images (including 3 channel 3D images)floating point imagesboolean imagessegmentation labels.npy, .ckl, or .nii formatFor .ckl and .nii formats, you must separately install crackle-codec and nibabel respectively.Installationpipinstall"microviewer[all_formats]"all_formats will install all supported formats for the CLI. By default, only .npy filesare supported.HistoryThis microviewer package has been a part of CloudVolume since 2018, but is now broken out into its own package for more flexible wider use. Microviewer uses a modified version ofhttps://github.com/seung-lab/data-cube-x/(2016) to represent the array in Javascript, which was originally developed for eyewire.org.
Package: microwave-usbfan
Micro Wave USB FanThis library is a pure Python reimplementation of the Jaycar RGB USB LED fan
(GH1031) protocol.
Communication occurs using USB HID reports as a transport. This library useshidapito do this across Linux, macOS,
FreeBSD and Windows.Installationpipinstallmicrowave-usbfanExample ImplementationTwo Text MessagesfromusbfanimportDevice,Program,TextMessage# A program is made up of a list of Messages# A "TextMessage" is a subclass of the generic Message classp=Program((TextMessage("Hello, World!"),TextMessage("How is everyone going?"),))# Open the device and programd=Device()d.program(p)Single Red DotfromusbfanimportColour,Column,Device,Message,Program# A generic "Message" is made up of 1 to 144 "Column" object# A "Column" has 11 boolean pixels and a "Colour"columns=[Column([True]+[False]*10,Colour.red)]for_inrange(7):columns.append(Column([False]*11,Colour.red))p=Program((Message(columns),))# Open the device and programd=Device()d.program(p)Rainbow MessagefromusbfanimportColour,Column,Device,Message,Program,TextMessage# We can cycle the rainbow here and fill all 144 columnsrainbow_colours=[Colour.red,Colour.yellow,Colour.green,Colour.cyan,Colour.blue,Colour.magenta]rainbow=[Column([True]*11,rainbow_colours[i%len(rainbow_colours)])foriinrange(Message.MAX_COLUMNS)]p=Program((TextMessage("Here comes the rainbow!"),Message(rainbow),))# Open the device and programd=Device()d.program(p)Mode ControlsFor each message, you can define how it opens, what it does once displayed, and
what it does when closing.fromusbfanimportColour,Column,Device,Message,Program,TextMessage,\MessageStyle,OpenTransition,CloseTransition# We can cycle the rainbow here and fill all 144 columnsrainbow_colours=[Colour.red,Colour.yellow,Colour.green,Colour.cyan,Colour.blue,Colour.magenta]rainbow=[Column([True]*11,rainbow_colours[i%len(rainbow_colours)])foriinrange(Message.MAX_COLUMNS)]p=Program((TextMessage("Here comes the rainbow!",message_style=MessageStyle.Flash,open_transition=OpenTransition.DownUp,close_transition=CloseTransition.DownUp),Message(rainbow,message_style=MessageStyle.Clockwise,open_transition=OpenTransition.FromMiddle,close_transition=CloseTransition.ToMiddle),))# Open the device and programd=Device()d.program(p)
Package: micro-wifi-manager
MicroPython WiFi ManagerA MicroPython WiFi manager for ESPx devices with fallback web configuration portalBased on tayfunulu'sWifiManager, but incorporates jczic'sMicroDNSSrvto create a captive portal by default so users don't have to find the access point's IP Address. The goal is to act similarly to tzapu's  popular C++WifiManagerwhile taking advantage of the simplicity of python for development.InstallationInstallation with upip⚠ Note: if you are using this package with OTA updates, be sure to avoid overwritinglib/where upip installs packages.From micropython command line runimport upip
upip.install("micro-wifi-manager")Manual InstallationCopy themicrowifimanager/directory to your device and refer tomain.pyfor usageMain FeaturesEasily setup device's WiFi connection from phone or computerWeb based connection manager with captive portalSave wifi password inwifi.dat(csv format)UsageSeemain.pyfor an examplefrommicrowifimanager.managerimportWifiManagerwlan=WifiManager().get_connection()TheWifiManagerlets you setup your wifi access point's name and password as well as the authentication modes# authmodes: 0=open, 1=WEP, 2=WPA-PSK, 3=WPA2-PSK, 4=WPA/WPA2-PSK
WifiManager(ssid='WifiManager', password='', authmode=0)LogicCheckwifi.datfile and try saved networks/passwordsHost WiFi access point and web server, and redirect all traffic to web server (captive portal)User can then provide the network password which is saved towifi.datRun user code
Package: microwler
Microwleris a micro-framework for asynchronous web crawling and scraping implemented in Python.
It is designed fordeepcrawls, i.e. retrieving every page of a specific website.Core features:define crawlers in asingle fileusing adeclarative approachcontrol your crawlers viaCLI,Python scriptsorHTTPcache your resultson diskuseincremental crawlingmode (only crawl new pages)usepre-built selectorsto scrape common data, i.e.<meta>or<title>easily definecustom selectorsusing XPath & CSSdefine "transformers" tomanipulate scraped dataafter crawlingexport datawith pre-built plugins or build your ownuse thebuilt-in web service(API + Frontend)Sounds good? Head over to theGetting Started guidenow!If you're familiar withMicrowler, you can install the package from PyPI using:pip install microwler.InspirationMany concepts were inspired by experience withScrapy, the industry standard for web crawling with Python.
The idea was to design a very minimalistic framework for analysing specific websites.
We tried to focus on making things as simple as possible for developers.
With Microwler, you can build crawlers and extract relevant data in a breeze - and in a single file.ContributingWe're happy about every meaningful contribution to this project via pull requests.
If needed, we'll setup more precise guidelines on how to contribute at some point.Note: you'll need to installpip install -r requirements-dev.txtto include required
dependencies for docs and tests.LicenseCopyright (c) 2020-2021 Maximilian WolfPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: microx
microx - a micro execution frameworkMicrox is a single-instruction "micro execution" framework. Microx enables a program to safely execute an arbitrary x86 or x86-64 instruction. Microx does not take over or require a process context in order to execute an instruction. It is easily embedded within other programs, as exampled by the Python bindings.The microx approach to safe instruction execution of arbitrary instructions is to require the user of microx to manage machine state. Microx is packaged as a C++Executorclass that must be extended. The Python bindings also present a class,microx.Executor, that must be extended. A program extending this class must implement methods such asread_registerandread_memory. When supplied with instruction bytes, microx will invoke the class methods in order to pull in the minimal requisite machine state to execute the instruction. After executing the instruction, microx will "report back" the state changes induced by the instruction's execution, again via methods likewrite_registerandwrite_memory.The following lists some use-cases of microx:Speculative execution of code within a debugger-like system. In this scenario, microx can be used to execute instructions from the process being debugged, in such a way that the memory and state of the original program will be preserved.Binary symbolic execution. In this scenario, which was the original use-case of microx, a binary symbolic executor can use microx to safely execute an instruction that is not supported or modelled by the symbolic execution system. The use of microx will minimize the amount of symbolic state that may need to be concretized in order to execute the instruction. Microx was used in this fashion in a Python-based binary symbolic executor. Microx comes with Python bindings for this reason.Headless taint tracking. Taint tracking can be implemented with microx, much as it would be with Intel's PIN, but without a process context. Microx can be integrated into a disassembler such as IDA or Binary Ninja and used to execute instruction, performing taint tracking along the way.Microx uses a combination of JIT-based dynamic binary translation and instruction emulation in order to safely execute x86 instructions. It is a 64-bit library, but it can execute 32-bit instructions that are not supported on 64-bit platforms. It can be easily embedded, as it performs no dynamic memory allocations, and is re-entrant.Microx depends onIntel's XEDinstruction encoder and decoder.InstallingMicrox has Python bindings; you can install them via pip on macOS and Linux:$pip3installmicroxBuilding (Python)If we don't supply a Python wheel for your platform, you can build microx yourself. You'll
need at least Python 3.5.First, build XED:$./scripts/bootstrap.shThen, usesetup.py build:$setup.pybuildBuilding (C++)Microx's C++ library can be built with CMake.The CMake build usesXED_DIRto locate the XED library and headers.To use thethird_partyXED build:$./scripts/bootstrap.sh
$exportXED_DIR=$(pwd)/third_partyThen, run a normal CMake build:mkdirbuild&&cdbuild
cmake..
cmake--build.
Package: microyc
microycminimalistic sdk for operating with yandex.cloudproject currently abandonned for nanoyc project, but still works fineInstallationJust as simple aspip install microycAuthorizationfor Amazon services autorize like with boto3Read more athttps://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.htmlUse .aws filestore it in/.aws with credentials/.aws/credentialsEnviromental variables (recomended)AWS_ACCESS_KEY_ID- The access key for your AWS account.AWS_SECRET_ACCESS_KEY- The secret key for your AWS account.to get this key generate a new static key for your service account at yandex cloud consoleusing Object storagepredefineBUCKETenvironment variable with name of bucketfrom microyc import Bucket

b=Bucket()  # or b=Bucket(BucketName='my-bucket')
b.upload('my_file.txt')moreu can user FifoQuequest, start virtual machines, use DocumentDatabase  and even suicide a turned virtual machinecheckobjects.pyfilerevision history0.0.6 fixed fifo recv() issue
0.0.5 Bug fixes and Bucket.upload_unique
0.0.4 added FifoQueue
Package: mics
Mixtures of Independently Collected SamplesFree software: MIT licenseInstallationpip install micsDocumentationhttps://mics.readthedocs.io/DevelopmentTo 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 toxChangelog0.2.0 (2018-05-09)Implementation of classessample,pool,mixture,MICSandMBAR.0.1.0 (2017-10-11)First release on PyPI.
Package: micsv
MICSVMICSSURVEY: automate MICS dataset downloadTODOLogin and downloadRefine popup deflectionInstallpip3installmicsvRequired libspip3installbs4
pip3installselenium# and install whatever libs missing on your machine...RunIn terminalpython3In pythonfrommicsvimportrun_micsrun_mics(versions=[],overwrite=False,save_to=".",sleep=5)versions: a list of MICS versions to download, empty means download
all from MICS2 to MICS6overwrite: overwrite exising file insave_todirectorysave_to: where to save the file, default to current working directory.
Perhaps better to doimportosos.chdir('path/to/where/to/save')run_mics()sleep: required, sometime MICS website load too slow and needed time to
solve reCaptcha.This program will open a new browser window (Firefox in this case).Use your username, password, pass the reCaptcha and click login (then make no
more movement in the browser please).The code will wait until MICS logged in successfully (5 minutes timeout) and
automatically redirect to surveys site.Example outputsProcessingpage1Processingpage2Processingpage3Processingpage4Processingpage5Processingpage6Thereare222file(s)detected.The-Gambia-MICS6-Datasets.zipisalreadyexisted.SkipdownloadingThe-Gambia-MICS6-Datasets.zip
Package: mictools
MICtools is an open source pipeline which combines the
TIC_e and MIC_e measures into a two-step procedure that allows to
identify relationships of various degrees of complexity in large datasets. TIC_e
is used to perform efficiently a high throughput screening of all the possible
pairwise relationships assessing their significance, while MIC_e is used to rank
the subset of significant associations on the bases of their strength. Homepage:https://github.com/minepy/mictools.
Package: midas
midasPython ≥3.8 driver forHoneywell Midas gas detectors.Installationpip install midasUsageCommand LineTo test your connection and stream real-time data, use the command-line
interface. You can read the state with:$ midas 192.168.1.100This will output a JSON object which can be further manipulated. See below for
object structure.PythonFor more complex behavior, you can write a python script. This solely uses
Python ≥3.5's async/await syntax.importasynciofrommidasimportGasDetectorasyncdefget():asyncwithGasDetector('192.168.1.100')asdetector:print(awaitdetector.get())asyncio.run(get())If the detector is operating at that address, this should output a
dictionary of the form:{'alarm':'none',# Can be 'none', 'low', or 'high''concentration':0.0,# Current gas concentration reading'connected':True,# Monitors heartbeat for connection'fault':{# Fault data, when applicable'code':'F39','condition':'User has generated a simulated fault.','description':'Simulated fault','recovery':'Reset simulated fault.','status':'Instrument fault'},'flow':514,# Flow rate, in cc / minute'high-alarm threshold':2.0,# Threshold concentration for high alarm trigger'ip':'192.168.1.192',# IP address of connection, can be used to link to Honeywell's own web interface'life':538.95,# Days until cartridge replacement required'low-alarm threshold':1.0,# Threshold concentration for low alarm trigger'state':'Monitoring',# Can be any option in `gas_detector.monitoring_status_options`'temperature':26,# Detector temperature, in celsius'units':'ppm'# Units for concentration values}Additionally, there are four commands which can be sent to the deviceClear all alarms and faults -detector.clear_alarms_and_faults()Inhibit alarms -detector.inhibit_alarms()Inhibit alarms and faults -detector.inhibit_alarms_and_faults()Turn off inhibition -detector.remove_inhibit()
Package: midas-analysis
MIDAS Analysis ToolDescriptionThis package contains the analysis tool of MIDAS. It allows to perform a basic analysis of the simulation database create by themidas-storemodule.This package is intended to be used with MIDAS and can be used with themidasctlcommand line tool.InstallationThis package will usually be installed automatically together withmidas-mosaik. It is available on pypi, so you can install it manually withpipinstallmidas-analysisUsageThe complete documentation is available athttps://midas-mosaik.gitlab.io/midas.To start the analysis, execute following commandmidasctlanalyzepath/to/my_db.hdf5wherepath/to/my_db.hdf5usually is the output directory defined in the runtime config. A new folder will be created with the same name as the database file and inside that folder you will find the analysis results.LicenseThis software is released under the GNU Lesser General Public License (LGPL). See the license file for more information about the details.
Package: midasML
# MIDASThis repository contains python code that implements various estimators of entropy and mutual information.In particular, Renyi Multi Information and Tsallis Multi Information estimators are available.## QuickstartInstall `midas` from the Python Package Index by using `pip`, via```bashpip install midasML```Alternatively, you can clone it from our Github repository with```bash$ git clone https://github.com/SheffieldML/midas```and then install it with```bash$ python setup.py install```from the main folder of `midas`.## Working exampleTo test `midas`, you can use the following example.Create a toy dataset specifying the correlation between some variables.```pythonimport numpy as npfrom midas.estimator import RenyiMutualInformationDivergence, MIDASfrom midas.model_assessment import permutation_test_score_groupsfrom midas.utils import sample_generationnp.random.seed(30)n_samples, n_dim = 30, 20rho_s = [.95, .9, .8, 0, 0]X, y, feature_names, groups = sample_generation.make_groups_joint(n_samples, n_dim, rho_s=rho_s)estimator = RenyiMutualInformationDivergence(alpha=0.99, k=3, n_iter=20)result = permutation_test_score_groups(MIDAS(estimator), X, y, groups, n_jobs=-1)```The first 3 groups of features are differentially co-regulated in half of the samples with respect to the other half, while the other groups of features are not (i.e., their co-regulation is the same in the two cases.)Hence, we can use the `RenyiMutualInformationDivergence` to analyse the co-regulation for different classes of samples, by using `MIDAS` class.`result` is a `pandas.DataFrame` which contains a summary of the result, which is something like| | score        | perm_scores           | p-value  | group ||-----| ------------- |:-------------:| -----:|:-----|0 |	0.614204 |	[0.119599699041, 0.17002017399, 0.000642361597...|	0.009901|	[0, 1, 2, 3]1	| 1.177062	|[0.00106705500132, 0.0115119749325, 0.00023392...|	0.009901	|[4, 5, 6, 7]2	| 0.223355	|[0.0, 0.0410519694311, 0.00417966412452, 0.007...|	0.029703	|[8, 9, 10, 11]3	| 0.010378	|[0.00187253953604, 0.00757194385644, 0.0002593...|	0.445545	|[12, 13, 14, 15]4	| 0.000000	|[0.00307271647955, 0.0, 0.0129193052203, 0.010...|	1.000000	|[16, 17, 18, 19]The first three results should have an high score and a low p-value, since the first three groups are differentially co-regulated by design (as specified before through the `rho_s` array). Hence, as in the example above, the method is capable to correctly address groups of variables as differentially co-regulated in the two classes of samples.## Other examplesFor other examples, please refer to Jupyter notebooks present in our Github page athttps://github.com/SheffieldML/midas/tree/master/notebooks.
Package: midas-powergrid
MIDAS Powergrid SimulatorDescriptionThis package contains a MIDAS module providing a pandapower simulator and a number of custom powergrids.Although this package is intended to be used with MIDAS, it does not depend from anything MIDAS-related except for themidas-utilpackage. You can use in any mosaik simulation scenario.InstallationThis package will usually installed automatically together withmidas-mosaik. It is available on pypi, so you can install it manually withpipinstallmidas-powergridUsageThe complete documentation is available athttps://midas-mosaik.gitlab.io/midas.Inside of MIDASTo use the powergrid inside of MIDAS, just addpowergridto your modulesmy_scenario:modules:-powergrid-...and configure it with (gridfileis required, everything else is optional and can be left out if the default values, shown below, are used):powergrid_params:my_grid_scope:gridfile:midasmvgrid_params:{}step_size:900plotting:Falseplot_path:_plots# Output path defined in runtime configsave_grid_json:FalseAll simulators that want to connect to this grid, will have to usemy_grid_scopeas theirgrid_namevalue. Activating the plotting will results in a considerably longer execution time. Activate it only if you really need this feature.The gridfile can be either a path to a .json or .xlsx file, a simbench grid code, one ofcigre_hv,cigre_mv,cigre_lv,midasmv,midaslv, orbhv, or an import path to a function or class that either returns a valid pandapower grid or is a pandapower grid itself. Thegrid_paramscan be used to pass keywork arguments to custom grids.Any mosaik scenarioIf you don't use MIDAS, you can add thepowergridmanually to your mosaik scenario file. First, the entry in thesim_config:sim_config={"Powergrid":{"python":"midas.modules.powergrid:PandapowerSimulator"},# ...}Next, you need to start the simulator (assuming astep_sizeof 900):powergrid_sim=world.start("Powergrid",step_size=900,plotting=False,plot_path="path/to/store/plots")Finally, the model needs to be started:powergrid=powergrid_sim.Grid(gridfile="midasmv",grid_params={})To connect the output of the grids' buses to another model, you have to get the list of bus models from the powergrids' children likebus_models=[eforeinpowergrid.childrenif"bus"ine.eid]and then connect those models either individually or in a loop, e.g.,forbusinbus_models:world.connect(bus,other_entity,"vm_pu","va_degree","p_mw","q_mvar")The inputs are generally handled in the same way. Have a look atpowergrid.childrento get the required entity eids.LicenseThis software is released under the GNU Lesser General Public License (LGPL). See the license file for more information about the details.
Package: midas-qmarket
MIDAS Powergrid SimulatorDescriptionThis package contains a MIDAS module providing a reactive power market simulator.Although this package is intended to be used with MIDAS, it does not depend from anything MIDAS-related except for themidas-utilpackage. You can use in any mosaik simulation scenario.The qmarket package currently depends on the grid operator agent, i.e., thegoamodule needs to be used as well.InstallationThis package is not part of the default packages for MIDAS.
But is available on pypi, so you can install it manually withpipinstallmidas-qmarketUsageThe complete documentation will be available athttps://midas-mosaik.gitlab.io/midasin the future.
Package: midas-qmarket-agents
MIDAS QMarket AgentsDescriptionThis package contains a MIDAS module providing reactive power market agents.Although this package is intended to be used with MIDAS, it does not depend from anything MIDAS-related except for themidas-utilpackage. You can use in any mosaik simulation scenario.However, it is designed to be used the themidas-qmarketpackage.InstallationThis package is not part of the default packages for MIDAS.
But is available on pypi, so you can install it manually withpipinstallmidas-qmarket-agentsUsageThe complete documentation will be available athttps://midas-mosaik.gitlab.io/midasin the future.Inside of MIDASTo use the qmarket agents inside of MIDAS, just addqmarket_agentsto your modulesmy_scenario:modules:-qmarket_agents-...LicenseThis software is released under the GNU Lesser General Public License (LGPL). See the license file for more information about the details.