Saravanan666/pypi-org huggingface dataset:
Package: sensitivity
sensitivityOverviewPython Sensitivity Analysis - Gradient DataFrames and Hex-Bin PlotsIt is common in financial modeling to conduct a sensitivity analysis on the model. This analysis runs the model changing the inputs values and collecting the outputs. Then the modeler can examine how the outputs change in response to the inputs changing. This library was created to ease this process, especially around visualization of the results.While it was developed for financial modeling, it can be used with any function to understand how changing the inputs of the function affect the outputs.Getting StartedInstallsensitivity:pip install sensitivityA simple example:fromsensitivityimportSensitivityAnalyzerdefmy_model(x_1,x_2):returnx_1**x_2sensitivity_dict={'x_1':[10,20,30],'x_2':[1,2,3]}sa=SensitivityAnalyzer(sensitivity_dict,my_model)plot=sa.plot()styled_df=sa.styled_dfs()LinksSee thedocumentation here.AuthorCreated by Nick DeRobertis. MIT License.
Package: sensorAtlas
SensorAtlasSensorAtlas is a Django App that serves an OGC SensorThings API implementation in Python.Detailed documentation is in the "docs" directory.Quick startThe following steps will explain how to add Sensor Atlas to an existing django application. If you do not
have a django application, create one and install Sensor Atlas to get started.NOTE: Sensor Atlas requires that django uses a PostGIS backend for its Database Settings.InstallsensorAtlas(e.g.pip install <path-to-file>/sensorAtlas-0.1.tar.gz)Add "sensorAtlas" to your INSTALLED_APPS setting like this (noterest_frameworkmust be included inINSTALLED_APPS):INSTALLED_APPS = [
    ...
    'rest_framework,
    'sensorAtlas',
]Also include the following Django Rest Framework settings in your settings.py file:REST_FRAMEWORK = {
    'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning',
    'URL_FIELD_NAME': 'selfLink',
    'ORDERING_PARAM': '$orderby',
    'DEFAULT_PAGINATION_CLASS': 'sensorAtlas.pagination.SensorThingsPagination',
    'PAGE_SIZE': 100,
    'TEST_REQUEST_DEFAULT_FORMAT': 'json'
}Include the sensorAtlas URLconf in your project urls.pyurlpatternslike this::urlpatterns = [
    ...
    path('api/', include('sensorAtlas.urls')),
]Runpython manage.py makemigrations sensorAtlas && python manage.py migrateto create the sensorAtlas models.Start the development server withpython manage.py runserverand visithttp://127.0.0.1:8000/api/v1.0/Testspython setup.py test
Package: sensorbee-python
sensorbee-pythonThis is a Python client library forSensorBeeREST / WebSocket API.
This library also provides utility commands (sbstatandsbpeek) which can be used to inspect SensorBee topology.Installpip install sensorbee-pythonTo use WebSocket Client API, you also need to installwebsocket-client:pip install websocket-clientRequirementsPython 2.7, 3.3, 3.4, 3.5 or 3.6.UsagePython APIIn most cases the only class you need to use ispysensorbee.api.SensorBeeAPI.
Here is an example:frompysensorbeeimportSensorBeeAPIapi=SensorBeeAPI('127.0.0.1',15601)api.create_topology('test')api.query('test','CREATE SOURCE ns TYPE node_statuses;')forrinapi.query('test','SELECT RSTREAM * FROM ns [RANGE 1 TUPLES];'):print(r)Seepydoc pysensorbee.apifor details.Commandssbstatprovides a brief summary of the topology status.$ sbstat -H 127.0.0.1 -P 15601 -t test
   Node                          Status    Received   Error   Output                            Sent     Queued   Dropped
-> node_stats                    running                      (total)                           5381                    0
                                                                  sensorbee_tmp_8               5381   0 (0.0%)
:: sensorbee_tmp_8               running       5381       0   (total)                           5381                    0
                                                                  sensorbee_tmp_select_sink_7   5381   0 (0.0%)
<- sensorbee_tmp_select_sink_7   running       5381       0Sources, streams and sinks are indicated by->,::and<-, respectively.sbpeekcan be used to peek what tuple is currently running through the specified source or stream.$ sbpeek -H 127.0.0.1 -P 15601 -t test -1 node_stats
{"behaviors": {"remove_on_stop": false, "stop_on_disconnect": false}, "node_type": "source", "output_stats": {"num_sent_total": 5893, "outputs": {"sensorbee_tmp_58": {"queue_size": 1024, "num_sent": 0, "num_queued": 0}, "sensorbee_tmp_8": {"queue_size": 1024, "num_sent": 5893, "num_queued": 0}}, "num_dropped": 0}, "state": "running", "node_name": "node_stats"}Seesbstat--helpandsbpeek--helpfor details.NoticeThis library is not a part of the official SensorBee project.In addition to APIs documented in theAPI Specification Version 1, this library supports some undocumented APIs, including WebSocket API.This project is a successor ofbeepy.LicenseMIT License
Package: sensorbucket
SensorBucket processes data from different sources and devices into a single standardized format.  An applications connected to SensorBucket, can use all devices SensorBucket supports.  Missing a device or source? SensorBucket is designed to be scalable and extendable. Create your own worker that receives data from an AMQP source, process said data and output in the expected worker output format.  Find out more at: https://developer.sensorbucket.nl/  Developed and designed by Provincie Zeeland and Pollex   # noqa: E501
Package: sensor-dataset
Outlier DetectionDetect and filter outliers.Documentation and Code can be found on GithubInstallpip install sensor_datasetZ-SCORE NormalizationNormalize data with Z-SCOREfromsensor_dataset.outlier_detectionimportZSCOREGet a normalized Koalas dataframe for the sensor dataset and fig objects by calling:kdf,figs=ZSCORE()figs['NORMAL'].write_image("images/zscore_normal.png")figs['RECOVERING'].write_image("images/zscore_recovering.png")figs['BROKEN'].write_image("images/zscore_broken.png")When running on a notebook you may show an interactive plot by using:fig.show()IQRFilter data using IQRfromsensor_dataset.outlier_detectionimportIQRkdf,figs=IQR()figs['NORMAL'].write_image("images/iqr_normal.png")figs['RECOVERING'].write_image("images/iqr_recovering.png")figs['BROKEN'].write_image("images/iqr_broken.png")
Package: sensordroid
Sensor Droid - Streams, in real-time, sensors and camera data directly to a client device over wireless network.https://sites.google.com/view/sensordroid/Turns an Android mobile device into a sensor module. Therefore, enabling you to perform further complicated tasks on your mobile application.
Sensor Droid main aim is to feed phone's sensor remotely to any client device e.g.  IoT, mobile robotics.
It provides better features and flexibility for amateurs and professionals to implement more complex ideas in their IoT or robotics application by minimizing project budget and using just phone's embedded sensors and camera.Sensor Droid supports multiple Android devices and multiple client devices.Sensor Droid device client can be implemented using .NET Library, Windows, Python and MATLAB .Supported Sensors:
Camera
Accelerometer
Orientation
Proximity
Magnetic
Light
Pressure
Steps
Temperature
Humidity
LocationIoT, Android, Python, MATLAB, Desktop, Windows, Sensors, Camera.
Package: sensorfabric
Python Package for Sensor FabricWelcome to the python package for SensorFabric.What is SensorFabric?SensorFabric is an initiative by University of Arizona's Center of Bioinformatics and Biostatistics (CB2)
to create homogenous layer for accessing, storing and processing sensor data.How to install it?You can install the sensorfabric python library usingpipas followspip install sensorfabricGetting StartedSensorFabric has several different modules. We try to give a basic overview here.Athena ModuleThe Athena module abstracts query execution and caching, by returning results from AWS Athena
as Pandas dataframes.To run this locally you must have aws credentials configured usingaws configureExamplefrom sensorfabric.athena import athena
import pandas as pd

# Create an object.
db = athena(database='MyExampleDatabase')

# Execute a query by performing a blocking operation.
frame = db.execQuery('SELECT "participantId" FROM "fitbit_hr" LIMIT 5')
# Print out the pandas frame.
print(frame.head())

# Queries can also be run async (callbacks are currently not supported)
executionId = db.startQueryExec('SELECT "participantId" FROM "fitbit_hr" LIMIT 5')
# Returns immidately, with the query execution ID. 

# Do some important work here

frame = db.queryResults(executionId)
# Returns the query result as a dataframe
print(frame.head())Enabling offline cachingIn order to enable offline caching for queries passofflineCache=TruetoAthena().
When caching is enabled a.cachefolder is creating in the calling directory, and query
results are stored in it. Files are named using the md5 hash of the query string.
Passcached=TruetoexecQuery()in order to use cached results. The following important
points need to be noted when using caching -Only exact query strings will cache to the same files.BothofflineCacheandcachedmust be set true for this to work.There is currently no time limit on the cached results (This might change).If you want to reset the cache you can delete the.cache directory.Exampledb = athena(database='MyBigDatabase', offlineCache=True)

# The first query will hit Athena but cache the local results in the .cache directory.
frame = db.execQuery('SELECT DISTINCT(pid) FROM temperature', cached=True)
print(frame.head())
# The second exact query will return results from the local cache.
frame = db.execQuery('SELECT DISTINCT(pid) FROM temperature', cached=True)
Package: sensorhandler
sensorhandlerMultipurpose sensorhandler, read the value from source & do somethings (send, save, trigger, ...) with it, as configed.installpip install sensorhandlerinputconfig.toml file on the current working directory. The contents of File is as follows:[[sources]]
  name   = "dht22"
  errorhandler = "errorhandler"
  [[sources.values]]
    name = "temp"
    handlers = [
      "send"#import os, "save"
    ]
  [[sources.values]]
    name = "humidity"
    handlers = [
      "send"#, "save"
    ]
  [[sources.values]]
    name = "humiditydeficit"
    handlers = [
      "send"#, "save"
    ]


[[sources]]
  name   = "mh-z19"
  [[sources.values]]
    name = "co2"
    handlers = [
      "send", "save"
  ]The array of tablesourcesis the array of data source sensor definition, consist of followings:name: Sensor handler's name. The same name python file (with ".py" extention) will be dinamically imported and functionread()on the imported module will be called. The return value of read() is expecte as a dictionally as key of value name and value like:{'humiditydeficit': '15.9', 'temp': 26.8, 'humidity': 37.6}values: handler difitition for each value, corresponding to the key of the dictionally of the return value of read() function.name: value namehandlers: Value handler's name. The same name python file (with ".py" extention) will be dinamically imported and functionhandle(data_source_name, data_name, value):will be called with the Sensor handler's name, value name, and sensor value.errorhandler: Error handler's name. The same name python file (with ".py" extention) will be dinamically imported for error handling of Sensor value reading. Currently, just stab.How to useas python program.python -m sensorhandler [--config config_file_path] [--imppath python_module_import_path] [ --list_imppath list_of_python_module_import_path]In case no --config, "config.toml" on the running path is used.
The path specified by --imppath and --list_imppath is used ad additional Python import library path.as python library.import sensorhandler

print (sensorhandler.read(config_file_path))history0.1.1  2018.09.28  first version confirmed Raspberry Pi model B2+0.1.2  2018.09.29  add config_file_path0.1.3  2018.09.29  add --config, --imppath, --list_imppath
Package: sensorhub
SensorHubThis is a simple library for use with theDockerPi/52Pi SensorHub (EP-0106).
You may still need to set up the board as documented on the 52pi wiki (configuring/enabling I2C).This library allows you to read from each sensor individually. It does not require the external temperature sensor to be connected,
however an exception will be thrown if you try to read from it while it is disconnected.How to use itInteracting with the SensorHub is easy. First create an instance of the SensorHub, which will open communication with it:fromsensorhub.hubimportSensorHubhub=SensorHub()Then it's just a case of calling the method for the value that you're after:temperature=hub.get_temperature()Other available methods are:hub.get_off_board_temperature()
hub.get_humidity()
hub.get_temperature()
hub.is_motion_detected()
hub.get_brightness()
hub.get_barometer_temperature()
hub.get_barometer_pressure()See the docstrings for more information on return types and exceptions that may be raised.
Package: sensoridRequest
long_description='The goal of the project is to provide a way to enable installation of carbon black sensors in a distrubuted manner as well as provide certain extended functionality such as registering users associated with sensors and tracking the sensor ID of systems that are currently being installed.-Tracking Sensor IDs:In order to track the sensor ID of systems Python is being utilized to perform acall to the Carbon Black (CB) Web API & return the sensor ID from the a list of all sensors on the CB server where the computer name of the sensor matches the computer name of the  system being installed.Home-page: https://pypi.python.org/pypi?%3Aaction=pkg_edit&name=sensoridRequestAuthor: Gregory GallawayAuthor-email: greg.gallaway@slaitconsulting.comLicense: MITDescription: UNKNOWNKeywords: Customer Designated,Modified Installer,Carbon Black InstallerPlatform: UNKNOWNClassifier: Development Status ::  3 - Beta - Proof of ConceptClassifier: Intended Audience :: Developers :: Customer OrganizationClassifier: Topic :: Modified Installer :: Carbon Black :: Customer Designated or DesignedClassifier: License :: OSI Approved :: MIT LicenseClassifier: Programming Language :: Python :: 2Classifier: Programming Language :: Python :: 2.6Classifier: Programming Language :: Python :: 2.7
Package: sensorizer
SensorizerSensorizer is a python library built to simulate a flow of sensor data to disk (Avro) or event hubs, is meant
to be the starting point of a data pipeline.The library has a docker container companion so you can have a source of sensor data in approximately 5 mins,
see the docker deployment section if your sink is either an avro file or an Azure Event Hub, if you want an
additional sink, have a look at the issues section.The main characteristic is that it tries to simulate traffic with
similar timings, that is, it will release up to 400K readings per second,
one by one. Then you can send it to a streaming sink (Azure Event Hub implemented)
or a disk option (Avro implemented).Docker deploymentThe deployment is container based, you can just pull the container:docker pull jgc31416/sensorizer:latestThen pass the configuration as environment variables, set up the environment variables
depending on the sink you want, this is an example for the Avro file sink using an environment file,
see /docs folder:docker run --env-file=avro_sink.cfg jgc31416/sensorizer:latestYou will get the generated files in the container.Avro file sinkYou might want to map the output folder of the dump file into your container host.export NUMBER_OF_SENSORS="10000"
export NUMBER_OF_HOURS="1"
export SINK_TYPE="file"                            # store sensor readings to a file
export RUNNING_MODE="batch"                        # send the readings one by one or in batch mode
export EVENT_DUMP_FILENAME="/tmp/event_dump.avro"  # Where to save the dataEvent Hub sinkexportNUMBER_OF_SENSORS="10000"exportNUMBER_OF_HOURS="1"exportSINK_TYPE="event_hub"# store sensor readings to a fileexportRUNNING_MODE="batch"# send the readings one by one or in batch modeexportEVENT_HUB_ADDRESS="amqps://<EventHubNamepace>.servicebus.windows.net/<EventHub>"exportEVENT_HUB_SAS_POLICY="<PolicyName>"exportEVENT_HUB_SAS_KEY="<SAS_KEY>"Distribution of the sensor readingsThe distribution of the sensor readings is the following:Frequencies are: 15% 1.0s, 65% 60.0s, 20% 3600.0s (Percentage is over the number of sensors,
s is seconds per reading)Base reading values: 50% 1, 40% 500, 10% 1000Sensor format@dataclassclassTimeserieRecord:"""Class for time series"""ts:float# epochdata_type:str# string(3)plant:str# string(3)quality:floatschema:str# string(6)tag:str# UUIDvalue:floatGetting started with the library developmentClone the project from github and enjoy.PrerequisitesThis software has been tested in Linux, it might work in other OSs but it
is definitely not warrantied.- Ubuntu latest stable / Debian Stretch / Fedora +25
- Python 3.7 (Dataclasses and typing in the code)
- Docker (if you want a container deployment)InstallingPython requirements:pip install -r requirements.txtRunning the testsAs simple as:pytest sensorizer/tests/Built WithPython 3.7DockerContributingSimply put, per branch features, merge to master, so:Fork the repo.Make a feature branch and develop.Test :)Create a pull request for your new feature.
Package: sensor-library-justgo13
Sensor projectUsing the projectInstallation:Enter the command:pip install sensor-library-justgo13Testing code:cd toC:\Users\USERNAME\AppData\Local\Programs\Python\Python36\Lib\site-packages\sensor_libRunlibrary_gui.pyto run the GUI.Reading documentation:Documentation downloadSource CodeProject Github pageSphinx DocumentationThis project was documented using Sphinx with Vim as the text editor. Sphinx creates .rst
files when initializing project and Vim is used to open and write to these .rst files. A link to download the version
of Vim used in this project can be found here:Download VimSphinx syntax can be be learned through this resource:Learn sphinx documentation syntaxTo initialize a sphinx documentation project use command:sphinx-quickstart. Make sure to
enable autodocs to import auto-generated code. Example of autodoc commands areautomodule, autoclass and
autofunction.To build a final project use commandmake htmlfor html pages andmake latexfor latex documents.Jupyter NotebookThis project has a Jupyter notebook to demonstrate the results of the X4 parser and threshold functions as well as
the results of running the TI radar parser.Running Ouster OS1 LidarTo run the OS1 Lidar, user must have working version of Ubuntu 16.04 or higher. All documentation
regarding building and running the Lidar software can be found in the pdf file.Required librariesnumpy, pandas, webbrowser, tkinter, csv, matplotlib, pymoduleconnector, time, optparse, math
Package: sensormapgeo
Sensormapgeo transforms a remote sensing image from sensor geometry (image coordinates without
geocoding/projection) to map geometry (projected map coordinates) or vice-versa based on a pixel-wise
longitude/latitude coordinate array.Free software: Apache-2.0Documentation:https://enmap.git-pages.gfz-potsdam.de/sensormapgeo/doc/Submit feedback by filing an issuehere.StatusSee also the latestcoveragereport and thepytestHTML report.Featurestransformation from sensor geometry (image coordinates) to map geometry (map coordinates)transformation from map geometry (map coordinates) to sensor geometry (image coordinates)CreditsThe sensormapgeo package was developed within the context of the EnMAP project supported by the DLR Space
Administration with funds of the German Federal Ministry of Economic Affairs and Energy (on the basis of a decision
by the German Bundestag: 50 EE 1529) and contributions from DLR, GFZ and OHB System AG.This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.
Package: sensormotion
Installation|Requirements|Usage|Contribution|Getting HelpSensor MotionPython package for analyzing sensor-collected human motion data (e.g.
physical activity levels, gait dynamics).Dedicated accelerometer devices, such as those made by Actigraph,
usually bundle software for the analysis of the sensor data. In my work
I often collect sensor data from smartphones and have not been able to
find any comparable analysis software.This Python package allows the user to extract human motion data, such
as gait/walking dynamics, directly from accelerometer signals.
Additionally, the package allows for the calculation of physical
activity (PA) or moderate-to-vigorous physical activity (MVPA) counts,
similar to activity count data offered by companies like Actigraph.InstallationYou can install this package usingpip:pip install sensormotionRequirementsThis package has the following dependencies, most of which are just
Python packages:Python 3.xThe easiest way to install Python is using theAnacondadistribution, as it
also includes the other dependencies listed belowPython 2.x has not been tested, so backwards compatibility is not
guaranteednumpyIncluded with Anaconda. Otherwise, install using pip (pip install numpy)scipyIncluded with Anaconda. Otherwise, install using pip (pip install scipy)matplotlibIncluded with Anaconda. Otherwise, install using pip (pip install matplotlib)UsageHere is brief example of extracting step-based metrics from raw
vertical acceleration data:Import the package:importsensormotionassmIf you have a vertical acceleration signalx, and its corresponding
time signalt, we can begin by filtering the signal using a low-pass
filter:b,a=sm.signal.build_filter(frequency=10,sample_rate=100,filter_type='low',filter_order=4)x_filtered=sm.signal.filter_signal(b,a,signal=x)Next, we can detect the peaks (or valleys) in the filtered signal, which
gives us the time and value of each detection. Optionally, we can
include a plot of the signal and detected peaks/valleys:peak_times,peak_values=sm.peak.find_peaks(time=t,signal=x_filtered,peak_type='valley',min_val=0.6,min_dist=30,plot=True)From the detected peaks, we can then calculate step metrics like cadence
and step time:cadence=sm.gait.cadence(time=t,peak_times=peak_times,time_units='ms')step_mean,step_sd,step_cov=sm.gait.step_time(peak_times=peak_times)For a more in-depth tutorial, and more workflow examples, please take a look
at thetutorial.I would also recommend looking over thedocumentationto see other
functionalities of the package.ContributionI work on this package in my spare time, on an “as needed” basis for my
research projects. However, pull requests for bug fixes and new features
are always welcome!Please see thedevelop
branchfor the
development version of the package, and check out theissues
pagefor bug reports
and feature requests.Getting HelpYou can find the full documentation for the packageherePython’s built-in help function will show documentation for any module
or function:help(sm.gait.step_time)You’re encouraged to post questions, bug reports, or feature requests as
anissueAlternatively, ask questions onGitter
Package: sensorpro-ble
sensorpro-bleSensorPro BLE DevicesInstallationInstall this via pip (or your favourite package manager):pip install sensorpro-bleContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: sensorpush-ble
SensorPush BLEParser for SensorPush BLE devicesInstallationInstall this via pip (or your favourite package manager):pip install sensorpush-bleContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.