Saravanan666/pypi-org huggingface dataset:
Package: north-c9
North C9The North C9 library is a low level library wrapping the North C9 Controller protocol.InstallationInstall thenorth_c9librarypipinstallgit+https://gitlab.com/north-robotics/north_c9Import theC9Controllerclass at the top of a Python file, or inside a Python consolefromnorth_c9.controllerimportC9ControllerCreate a newC9Controllerinstance to connect to the C9 controllercontroller=C9Controller()Now you can move axes, toggle outputs and move the N9 (if available)# move axis 5 to 0 countscontroller.move_axis(5,0,velocity=1000,acceleration=5000)# rotate axis 5 once (motors have 1000 counts / revolution)controller.move_axis(5,1000,velocity=1000,acceleration=5000,relative=True)# start spin axis 5controller.spin_axis(5,velocity=1000,acceleration=5000)# stop spinning axis 5controller.spin_axis_stop(5)# turn output 0 on and offcontroller.output(0,True)controller.output(0,False)controller.output_toggle(0)# home the N9controller.home()# move the N9 to x=0 mm, y=150 mm, z=150 mm and gripper=90 degcontroller.move_arm(0,150,150,gripper=90)
Package: north-devices
North Devices (north_devices)Thenorth_deviceslibrary contains drivers and utilities for third-party devices that can be used in the North
Robotics ecosystem.InstallationRunpip install north_devicesto install, or addnorth_devicesto yourrequirements.txtfile.Pumps (north_devices.pumps)Tecan Cavro (tecan_cavro)There is a driver for the Tecan Cavro series of pumps available that uses the binary protocol to communicate with
Cavro pumps on a network.Usagefromftdi_serialimportSerialfromnorth_devices.pumps.tecan_cavroimportTecanCavroserial=Serial(baudrate=38400)# Cavro pumps default to 9600cavro=TecanCavro(serial,address=0,syringe_volume_ml=1000)TecanCavro.home_all()# Homes all TecanCavro pump instances# you can perform absolute and relative moves in counts or mL, with optional velocitycavro.move_absolute_counts(500)cavro.move_absolute_ml(1000,velocity_counts=500)cavro.move_relative_counts(100,velocity_counts=1000)cavro.move_relative_ml(500)# you can change valve positions with `move_valve`cavro.move_valve(1)# moves valve to port 1# there is also a higher-level dispense method that pumps from a port to a portcavro.dispense_ml(2000,from_port=1,to_port=2)# you can also batch a series of commands to be sent at oncecavro.start_batch()cavro.move_valve(1)cavro.move_absolute_ml(500)cavro.move_valve(2)cavro.move_absolute_ml(0)cavro.execute()# you can use the `broadcast=True` flag to execute batch commands for all pumps at once# there is also a basic loop command that can be used in a batch commandcavro.loop_start()cavro.move_valve(1)cavro.move_absolute_ml(500)cavro.move_valve(2)cavro.move_absolute_ml(0)cavro.loop_end(10)# loop 10 timescavro.execute()# multiple cavro instances can share the same serial connection if they are on a networknetwork=Serial(baudrate=9600)cavro1=TecanCavro(network,0)cavro2=TecanCavro(network,1)# you can send batch commands to multiple cavros then execture them simultaneouslycavro1.start_batch()cavro1.move_relative_ml(100)cavro2.start_batch()cavro2.move_absolute_ml(100)TecanCavro.broadcast_execute(cavro1,cavro2)# this will broadcast to all pumps if none given
Package: northgravity-utils
NORTH GRAVITY PYTHON UTILSThis document describes the North Gravity Python Utils package which enables users to use the NG platform tools and most common functions within their python scripts / tasks repositories.The Python Utils can be used within:a single python script that is ran thanks to the Python Runner task within a pipeline in the NG applicationa single Jupyter Notebook that is ran thanks to the Jupyter Runner task within a pipeline in the NG applicationan ensemble of python scripts that are part of a container, for a Task created by the user, used in a pipeline in the NG applicationNG_Utils cover most frequently used functions for data/files handling purposes.The scope of the NG_Utils:DataHandler- splitting data based on train/test labels, handling dates in datasetsFileHandler- downloading/uploading model-specific datasets from/to the data lake, handling datasets formatsBackTest- preparing short or extended backtest based on models resultsStatTest- preparing report and running statistical tests for stationarity, autocorrelation and volatitity clustering-TaskExecUtils- auxiliary functions used in executing tasksHow to install and set the package:Installpip3 install northgravity_utils==0.1.1As the library is available from pip, it can be installed as a specific version within a Python Task from within requirements.txt just by adding:northgravity_utils==0.1.1The package relies on the requests library so, in the project, the user must install this library in the requirements.txt file.pip3 install requests==2.27.1Environment VariablesThe package uses information from the environment variables. They are necessery for functionality of Nortygravity SDK package, used in Northgravity Utils
Environment variables are automatically provided when running a script within a pipeline (as a Task or within the Python/Jupyter Runners).
If running locally the script, users must set them in the project to be able to run the project locally.Mandatory environment variables to set:LOGIN → login received from NGPASSWORD → password to log in. Credentials are used to generate the token so that each request is authenticated.NG_API_ENDPOINT → the URL to the NG platform API (by default, the url is set tohttps://api.northgravity.com)
Package: north-manager
North Roboticsnorth_managerThenorth_managerutility is a command line and GUI application for managing and configuring North Robotics devices.
Currently it can check and update firmware on North Robotics C9 controllers.InstallationThe CLI and UI can be installed with pip:$ pip install north-managerUIThe GUI can be launched by running:$ north_manager uiCLIAlong with a GUI, there is also a command line interface available.north_manager firmware.infoPrints information about connected devices, including firmware version and COM port.north_manager firmware.list-versions <model>Prints all available firmware versions for the given controller model (Eg.n9,spin,dev).north_manager firmware.updateUpdates firmware to latest version on any connected controllers.
Package: north-robots
North RobotsThenorth_robotslibrary provides a high-level API for interacting with North Robotics robots and components.InstallationInstall thenorth_robotslibrarypipinstallgit+https://gitlab.com/north-robotics/north_robotsImport theC9ControllerandN9Robotclassesfromnorth_c9.controllerimportC9Controllerfromnorth_robots.n9importN9RobotNow create instances of the controller and robotcontroller=C9Controller()robot=N9Robot(controller)Now you can home and move the N9 robot arm aroundrobot.home()robot.move(0,150)robot.move(0,150,200)robot.move(gripper=90)robot.elbow.move_degrees(-90)
Package: northstar
northstarSingle cell type annotation guided by cell atlases, with freedom to be queer.Brief descriptionnorthstaris a Python package to identify cell types within single cell transcriptomics datasets.
northstar's superpower is that it learns from cell atlases but still allows queer cells to make their own cluster if they want to.Also, northstar was heavily developed duringPride Month.Atlas resourcesCurated averages and subsamples from several atlases:https://northstaratlas.github.io/atlas_landmarks/If you want us to add you cell atlas, open an issue on:https://github.com/northstaratlas/atlas_landmarks/issuesDocumentationhttps://northstar.readthedocs.ioInstallationpipinstallnorthstarTo automatically download and use our online atlas collection athttps://northstaratlas.github.io/atlas_averages/, you will need to call:pipinstall'northstar[atlas-fetcher]'Dependenciesnumpyscipypandasscikit-learnanndatapython-igraph>=0.8.0leidenalg>=0.8.0It is recommended that you install python-igraph and leidenalg usingpip. However, any installation (e.g. conda) that includes recent enough versions of both packages should work.Optional deps to use our online atlases:requestsloompyscanpypynndescent(only useful if you usescanpyas well)If you havescanpyinstalled,northstarwill use it to speed up a few operations (PCA, graph construction). You can turn this off in two ways:Uninstallscanpyis you don't need it for anything else, orSet the environment variableNORTHSTAR_SKIP_SCANPYto anything except empty string, e.g. in a notebook:importosos.environ['NORTHSTAR_SKIP_SCANPY']='yes'importnorthstarasns(restofthenotebook/script)Hot-swapping between the two modes (w or w/oscanpy) is not currently supported.UsageSee the paper below or the documentation for detailed instructions and examples. The simplest way to usenorthstaris to classify a new single cell dataset using one of the available atlases, e.g.Darmanis_2015on brain cells:importnorthstar# Choose an atlasatlas_name='Darmanis_2015'# Get a gene expression matrix of the new dataset (here a# random matrix for simplicity)N=200L=50new_dataset=pd.DataFrame(data=np.random.rand(L,N).astype(np.float32),index=<gene_list>,columns=['cell_'+str(i+1)foriinrange(N)],)# Initialize northstar classesmodel=northstar.Averages(atlas='Darmanis_2015',n_neighbors=5,n_pcs=10,)# Run the classifiermodel.fit(new_dataset)# Get the cluster memberships for the new cellsmembership=model.membershipCitationIf you use this software please cite the following paper:Fabio Zanini*, Bojk A. Berghuis*, Robert C. Jones, Benedetta Nicolis di Robilant, Rachel Yuan Nong, Jeffrey Norton, Michael F. Clarke, Stephen R. Quake.Northstar enables automatic classification of known and novel cell types from tumor samples.Scientific Reports 10, Article number: 15251 (2020), DOI:https://doi.org/10.1038/s41598-020-71805-1Licensenorthstaris released under the MIT license.NOTE: The module leidenalg to perform graph-based clstering is released
under the GLP3 license. You agree with those licensing terms if you use
leidenalg within northstar.
Package: norton-beer
norton_beerThe 'norton_beer' library is a python tool box for the Norton-Beer apodization functions.Main featuresNorton-Beer apodization window generation in spatial domainthe analytical Fourier transform of the apodization window also known as instrument line shape (ILS)generation of new apodization window for a fixed spatial resolution of the ILS so that the sides lobes are minimizedInstallationTo use norton_beer, first install it using pip:pip install norton-beerTestingTo test thenorton_beerpackage, clone the repository and run:pytestNote that pytest needs to be installed on the local machine.DocumentationDocumentation
Package: norutil
All rights reserved.Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.Description: # NorUtil## DescriptionPrototype package for my personal developmentPlatform: UNKNOWN
Package: norwegian-numbers
Norwegian numbersMake and verify official Norwegian numbers:KID-nummer:make_kid_numberandverify_kid_numberOrganisasjonsnummer:make_organisation_numberandverify_organisation_numberFødselsnummer:make_birth_numberandverify_birth_numberKontonummer:make_account_numberandverify_account_numberThis currently only concerns itself with the control digits.InstallationTo install from PyPi as a module in your environment:pip install norwegian-numbersTo install from source as a module in your environment:python setup.py installCode usage from installationExample code usages after installation:>>> import norwegian_numbers as nn
>>> nn.make_kid_number('1234', 'mod10')
'12344'
>>> nn.verify_kid_number('12344', 'mod10')
True
>>> nn.make_account_number('1234567890')
'12345678903'
>>> nn.make_organisation_number('12345678')
'123456785'
>>> nn.make_birth_number('311299567')
'31129956715'Running from command lineUsage from command line:$ python -m norwegian_numbers --help
usage: __main__.py [-h]
                (-m {kid10,kid11,organisation,birth,account} | -v {kid10,kid11,organisation,birth,account})
                value

Generate or verify KID-nummer, organisasjonsnummer, fødselsnummer, kontonummer

positional arguments:
value                 The value to make or verify based on

optional arguments:
-h, --help            show this help message and exit
-m {kid10,kid11,organisation,birth,account}, --make {kid10,kid11,organisation,birth,account}
                        Choose what to make
-v {kid10,kid11,organisation,birth,account}, --verify {kid10,kid11,organisation,birth,account}
                        Choose what to verifyExample usage:$ python -m norwegian_numbers -m kid10 1234
12344
$ python -m norwegian_numbers -v kid10 12344
True
$ python -m norwegian_numbers -m account 1234567890
12345678903
$ python -m norwegian_numbers -m organisation 12345678
123456785
$ python -m norwegian_numbers -m birth 311299567
31129956715Testing from sourceTo run the tests:python -m unittest discoverOr if you have tox:toxOr for coverage (with html report):coverage run -m unittest discover
coverage htmlSourcesSome sources on the background material:KID-nummerFødselsnummerOrganisasjonsnummerKontonummerMOD10MOD11DistributionThe distribution was created by the following commands:python setup.py sdist bdist_wheel
python -m twine upload dist/*
Package: nose
nose extends the test loading and running features of unittest, makingit easier to write, find and run tests.By default, nose will run tests in files or directories under the current
working directory whose names include “test” or “Test” at a word boundary
(like “test_this” or “functional_test” or “TestClass” but not
“libtest”). Test output is similar to that of unittest, but also includes
captured stdout output from failing tests, for easy print-style debugging.These features, and many more, are customizable through the use of
plugins. Plugins included with nose provide support for doctest, code
coverage and profiling, flexible attribute-based test selection,
output capture and more. More information about writing plugins may be
found on in the nose API documentation, here:http://readthedocs.org/docs/nose/If you have recently reported a bug marked as fixed, or have a craving for
the very latest, you may want the development version instead:https://github.com/nose-devs/nose/tarball/master#egg=nose-dev
Package: nose2dep
Nose2 plugin for test dependenciesThis is based on https://github.com/Zitrax/nose-dep/, ported to nose2 and tweaked slightly.This plugin allows you to express dependencies between your tests, or a preferred running order for them. Although this contravenes best practices (unit tests should be separate, and be runnable independently - Ruby’s minitest randomises the test order for exactly this reason), it may be useful in some cases:you may have very slow integration tests where redoing what test A did just to run test B would simply be too costlyyou may have ‘smoke tests’ which should run first, so that the rest can be skipped if those tests fail - for example, if you’re writing a multiplication library and 2*2 doesn’t work, there’s no point testing anything more complicatedTo use it, import the depends decorator (from nose2dep.core import depends) and decorate your testcases with@depends(before="test_name"),@depends(after=["test_name","test_name2"])or@depends(priority=6)(or some combination of those arguments, e.g.@depends(before="test_name",after="test_other",priority=100)).DependenciesTo declare that your test needs to run before or after some other specific test(s), passbefore=or theafter=parameters to@depends. The arguments can be:the name of the other test method as a stringthe other test method object itselfa list of either of the aboveIf test B depends on test A, and test A fails, then B will be skipped (allowing the ‘smoke tests’ use-case above).Note that all dependencies are treated as soft, unlike the original nosedep. They will only affect the test ordering, not force inclusion. For example if we have:@depends(after=test_b)
def test_a:
  pass

def test_b:
  passand run all tests they would run in the order b,a. If you run only test_a, though, it won’t pull in test_b to satisfy the dependency - it’ll just run test_a.PrioritiesEach test can be given an integer priority (defaulting to 50) and the tests will run in order from lowest to highest. Dependencies take precedence so in total the ordering will be:All tests with a priority lower or equal to the default that are not part of any dependency chain ordered first by priority then by name.Priority groups in order, while each priority group is internally ordered the same as point 1.All tests with priority higher than the default that are not part of any dependency chain ordered first by priority then by name.Note: Currently no support for Python 2.6 and 3.2. Should work for 2.7 and 3.3+.
Package: nose2django
A plugin pair for nose2 that runs your django (>=1.4) tests through the nose2 command and also supportsdjango-configurationssettings management. It lets django initialise the test environment and setup the order of the test suite, but nose2/unittest2 handles the test discovery and execution.There is another project calleddjango-nosewhich is authored by one of the nose2 devs. It uses the standard django approach of setting an alternative test runner and running via manage.py. I was interested with the move to shift setup.py configuration into setup.cfg and wanted to try that pattern for running tests rather that wrapping configuration into a custom test runner. Modern django has refactored the way a project is initialised which means there is less dependency on using manage.py and django-admin.py as the only possible entry points into your django project.Installation$pipinstallnose2djangoCreate a nose2.cfg file in your project’s root directory (where manage.py is) and register the plugins in the correct order:[unittest]
plugins = nose2django.config
        nose2django.nose2django

[django-config]
always-on = True

# optional settings
settings = yourproject.settings
configuration = YourTestConfiguration

[django-runner]
always-on = TrueYou can optionally set thesettingsandconfigurationto a django settings module and a django-configurations configuration. It takes precedence over any existing environment.UsageAs per nose2, optionally with either of the django-runner options.$nose2--settings=example.settings.test--configuration=TestSettingsPatternsFor django app test driven development of apps you want only as much django settings as required. Create a tests folder in your top level directory (avoid using the name tests - use something like test_yourapp to avoid name clashes), and put a minimal settings file in there and an__init__.pyfile to make it importable. Something like:DATABASES={'default':{'ENGINE':'django.db.backends.sqlite3'}}INSTALLED_APPS=('django.contrib.auth','django.contrib.contenttypes','django.contrib.sessions','yourapp',)ROOT_URLCONF='yourapp.urls',# if you have urlsSECRET_KEY='1234'Acknowledgementsnose2django re-uses parts of the existing django test runner code as licensed bydjango.Changelogv0.1.2 (2013-4-13)Add South compatibility.v0.1.1 (2013-4-6)Fix issue with django logging setup when nose -v.v0.1 (2013-03-29)Initial public (correctly packaged) release. Thanks tox.
Package: nose2-html-report
# Nose2 HTML Report[![Build Status](https://travis-ci.org/mgrijalva/nose2-html-report.svg?branch=master)](https://travis-ci.org/mgrijalva/nose2-html-report)[![Coverage Status](https://coveralls.io/repos/github/mgrijalva/nose2-html-report/badge.svg?branch=master)](https://coveralls.io/github/mgrijalva/nose2-html-report?branch=master)### IntroductionA [nose2](https://github.com/nose-devs/nose2) plugin for generating searchable HTML reports of your test results.- docstrings from tests are captured as test descriptions- if a test fails, the traceback will be captured in the report- report is searchable and filterable by passed/failed/error/etc.![Report Screenshot](https://raw.githubusercontent.com/mgrijalva/nose2-html-report/master/docs/images/report.png)### InstallationYou can install the Nose2 HTML Report Plugin using `pip`:```pip install nose2-html-report```### ConfigurationTo get `nose2` to recognize the plugin add an entry into the `plugin` key of the `unittest` section of your `nose2.cfg` file. Configurations for the plugin should be placed into an `html-report` section of the configuration file. Below is a working example:```[unittest]plugins = nose2_html_report.html_report[html-report]always-on = True```#### Additional SettingsSpecify the path for the HTML report. Defaults to `report.html````[unittest]plugins = nose2_html_report.html_report[html-report]always-on = Truepath = test_results/my_custom_report_file.html```### UsageCommand line flag:```nose2 --html-report```If you have `always-on=True` inside your `nose2.cfg`:```nose2```### ContributingThis is a small side project of mine. Feel free to submit any pull requests.
Package: nose2-kflag
OverviewThis package provides a nose2 plugin implementing the -k flag known from
unittest discover. The plugin allows to select tests by specifying on or more
substring patterns.PatternsMatching is performed against the full dotted name of each test. If a pattern
is prefixed with ‘!’ its meaning is inverted, and only tests not matching
the pattern will be selected. Multiple -K flags (plugin rules mandate
uppercase) may be given. A test is selected ifanyof the given
positive patterns andallof the given negative patterns apply.
Patterns are case sensitive.ExamplesRun one test:nose2 -K test_fooRun one test of a specific test class:nose2 -K FooTestCase.test_barRun all tests of a test class:nose2 -K FooTestCaseRun all foo and bar tests except those in the functional directory:nose2 -K foo -K bar -K '!functional'Installationpip install nose2-kflagThen add the plugin to your nose2.cfg:[unittest]
plugins = nose2_kflagChangelog1.0 - 2020-06-14Initial release.
Package: nose2rt
nose2rt - nose2 data collector for TestgrPlugin sends nose2 data to Testgr server.Setuppip install nose2rtFind your nose2 config file and configure as described below.Example:[unittest]
plugins = nose2rt.rt

[rt]
endpoint = http://127.0.0.1/loader  # Your Testgr service URL
screenshots_var = t_screen
return_job_file = testgr_last_job.txt
show_errors = True # show POST errors

[test-result]
always-on = True
descriptions = TrueLaunchnose2 --rt -> will launch nose2 with nose2rt plugin.Additional parameters:--rte "your_environment" -> will launch nose2 and send your environment name as additional info to the Testgr server.--rt-job-report - send email after job finish.--rt-return-job - write last finished job UUID in file, configured by "return_job_file" config variable.--rt-custom-data - send any custom data to Testgr in Dict format. Example:--rt-custom data='{"Git":"dev-branch"}'AuthorsAndrey SmirnovLicenseThis project is licensed under the MIT License - see theLICENSEfile for details