Saravanan666/pypi-org huggingface dataset:
Package: niftiprocessing
NiftiProcessingA nifti file processing toolUnder developmentThis software has NOT been approved for medical analysis/diagnosis. Please use other
approved software in for medical use.Optionspositional arguments:
  path                  Path to file

optional arguments:
  -h, --help            show this help message and exit
  --precision {32,64}   Sets datatype precision in float32 or 64
  --info, -i            Outputs .nii file metadata
  --plot PLOT, -p PLOT  Plots image of 2nd/3rd dimension in .nii file 
                        (Requires MatplotLib)
  --align, -a           Orients .nii file in MNI152 space
  --normalize, -n       Normalizes .nii file values within set values 
                        (Default: 0.,1.)
  --normalize-lower     Lower value for normalization (Default: 0.)
  --normalize-upper     Lower value for normalization (Default: 0.)
  --rotate, -r          Rotates .nii file by 90 degress in 1st and 2nd dimension
  --output, -o          Filename for .nii file generation 
                        (Note: Currently erases orginal metadata)Usage Examples# Orients nifti file to MNI152 space$niftiprocessingsample.nii.gz-a-ooutput.nii.gz# Plot slice 150 with matplotlib$niftiprocessingsample.nii.gz-p150Actions to implement:InputSingleBatch (directory)Toolsresizeresize with padresize with cropfliprotateinvertdenoisenormalizealignInformationscan informationVisualizeterminal drawing output for orientationOutputSingleBatch (directory)
Package: nifti-snapshot
nifti-snapshotnifti-snapshotis a tool to quickly capture nifti image as apngorjpegfigures.$pipinstallnifti_snapshotFor full documentation:HereTBSS figuresFrom commandlineSnapshot of antbss_fillimagefw=tbss_FW_tfce_corrp_tstat2_filled.nii.gz

./nifti_snapshot\--input${fw}\--tbss\--output_filecli_test_fw.png\--cmap"Blues_r"\--title"Significant changes in FW in group A"\--cbar_title'Increased FW'Snapshot of twotbss_fillimages with overlap highlightfa=tbss_FA_tfce_corrp_tstat1_filled.nii.gzfat=tbss_FAt_tfce_corrp_tstat1_filled.nii.gz

./nifti_snapshot\--input${fa}${fat}\--tbss\--output_filecli_test.png\--cmap"Blues_r""autumn"\--title"Significant changes in FA and FAt in group A"\--cbar_title'Reduced''Reduced FAt''Overlap'\--overlap\--overlap_cmap"summer"\--overlap_alpha0.8From pythonSnapshot of antbss_fillimagefromnifti_snapshotimportnifti_snapshotfw='tbss_FA_tfce_corrp_tstat1_filled.nii.gz'fw_color='Blues_r'tbssFigure=nifti_snapshot.TbssFigure(image_files=[fw],output_file='docs/fw_example.png',cmap_list=[fw_color],cbar_titles=['Increased FW'],alpha_list=[0.8],title='Increased Freewater in group A',cbar_x=0.35,cbar_width=0.3)tbssFigure.create_figure_one_map()Snapshot of twotbss_fillimages with overlap highlightfromnifti_snapshotimportnifti_snapshotfa='tbss_FA_tfce_corrp_tstat1_filled.nii.gz'fat='tbss_FAt_tfce_corrp_tstat1_filled.nii.gz'fa_color_1='Blues_r'fa_color_2='autumn'fa_color_overlap='summer'tbssFigure=nifti_snapshot.TbssFigure(image_files=[fa,fat],output_file='docs/fa_fat_example.png',cmap_list=[fa_color_1,fa_color_2],overlap_cmap=fa_color_overlap,cbar_titles=['Reduced FA','Reduced FAt','Overlap'],alpha_list=[1,1,0.8],title='Significant changes in FA and FAt in group A')tbssFigure.create_figure_two_maps_and_overlap()
Package: niftools-sphinx-theme
NifToolsSphinxtheme was created to mimic theNifToolswebsite,
which is running amodified versionofYummy-Jekyl.This theme is still in planning/development stage!
Please wait until ver1.0.0before using this theme!FeaturesSupports these extensions:autodocviewcodeTemplatesSee MoreAbout PageBlog PageProjects PageInstallationThis theme can be found onPyPiand can be installed through pippip install --upgrade niftools_sphinx_themeInside your sphinxconf.pyfile you must put this insideimportniftools_sphinx_themeextensions=["niftools_sphinx_theme",...]html_theme="niftools_sphinx_theme"CustomizationThis theme was created with customization is mind.DevelopmentI include the built files so all you have to do is run sphinx,
but if you wish to work on this project we usewebpackto compile
and copy allCSS,JavaScriptand fonts to the static folder.
Package: nifty4gemini
Nifty4GeminiA Python Data Reduction Pipeline for the Gemini-North Near-Infrared Integral
Field Spectrometer (NIFS).Full documentation:ReadTheDocs.This is a new data reduction Python pipeline that uses Astroconda and the Gemini
IRAF Package to reduce NIFS data. It offers a complete data reduction process from
sorting the data to producing a final flux calibrated and wavelength calibrated
combined cube with the full S/N for a science target.This pipeline is open source and it is supported via theGemini Data Reduction User Forum.Any feedback and comments (mbusserolle@gemini.edu) are welcome!CopyrightFor more details, please read the LICENSE.How to Submit Bugs and RequestsVery important:do not submit a Gemini help desk ticket!If you want to report a problem, use theGemini Data Reduction Forum threador create an issue in this repo.InstallationPre-RequisitesMake sure you have the latest version of Gemini Astroconda installed, have activated an Astroconda environment and have set up PYRAF.
You can find instructions for installing Astrocondahere. PYRAF can be set up by running the mkiraf command
in your “~/iraf” directory.Installing>From PyPi.org:pip install nifty4geminiInstalling in Editable ModeIf you want to edit the Nifty source code, it’s recommended to install Nifty in editable Mode. First obtain the Nifty source code. You
can do this by downloading and unpacking the latest release or cloning this github repository.Once you have the source code, change to the top level of the source code directory (you should see the setup.py file). Run:pip install -e .to install Nifty in editable mode. Now you can edit your copy of the Nifty source code and run it without having to reinstall every time.Quick StartTo run Nifty4Gemini, getting data reduction parameters from an interactive input session:runNifty nifsPipeline -iTo run Nifty in full-automatic mode with default input parameters, provide the -f flag
and a full local path to the raw data or a Gemini Program ID string (Eg: GN-2013A-Q-62).runNifty nifsPipeline -f <data_location>LicenseSee the LICENSE file in the current directory. Note that downloadFromGeminiPublicArchive does not use the MIT
license. Refer to the LICENCE file in the downloadFromGeminiPublicArchive directory to view the appropriate license.
Package: niftypet
NiftyPET: High-throughput image reconstruction and analysisDocumentation:https://niftypet.readthedocs.ioNiftyPETis a software platform and a Python namespace package encompassing sub-packages for high-throughput PET image reconstruction, manipulation, processing and analysis with high quantitative accuracy and precision.  See below for the description of the above image, reconstructed usingNiftyPET[*].NiftyPETincludes two packages:nimpa:https://github.com/NiftyPET/NIMPA(neuro-image manipulation, processing and analysis)nipet:https://github.com/NiftyPET/NIPET(quantitative PET neuro-image reconstruction)The core routines are written in CUDA C and embedded in Python C extensions.  The scientific aspects of this software platform are covered in two open-access publications:NiftyPET: a High-throughput Software Platform for High Quantitative Accuracy and Precision PET Imaging and AnalysisNeuroinformatics (2018) 16:95.https://doi.org/10.1007/s12021-017-9352-yRapid processing of PET list-mode data for efficient uncertainty estimation and data analysisPhysics in Medicine & Biology (2016).https://doi.org/10.1088/0031-9155/61/13/N322[*]The above dynamic transaxial and coronal images show the activity of18F-florbetapir during the one-hour dynamic acquisition.  Note that the signal in the brain white matter dominates over the signal in the grey matter towards the end of the acquisition, which is a typical presentation of a negative amyloid beta (Abeta) scan.AcknowledgementsThis project is being developed at University College London (UCL). Initially, it was supported and funded by the Engineering and Physical Sciences Research Council (EPSRC) of the United Kingdom (UK).  Currently, the project is being further developed under the following funding streams:TheInnovative Medicines Initiative 2Joint Undertaking under grant agreement No 115952. This Joint Undertaking receives support from the European Union’sHorizon 2020research and innovation programme andEFPIA.TheDementias Platform UKMR-PET Partnership, supported by the Medical Research Council (MRC) in the UK.We gratefully acknowledge the support ofNVIDIA Corporationwith the donation of the Tesla K20 and Titan X Pascal GPUs used for this research and work.Copyright 2018-21Pawel J. Markiewicz@ University College LondonCasper O. da Costa-Luis@ King’s College LondonContributors
Package: nifverifier
NIF PT Verify and Create python packageThis is a simple package to verify and create new NIF (Número Identificação Fiscal) in Portugal.You can install the package using pippip install nifverifierThe solo contributor for this package is the geek, gentle, innocent and kind-hearted CharlieBrownHow to use this package:fromnifverifierimportam_i_a_dead_ass_valid_nif,generate_dead_ass_valid_nifinvalid_nif="123123123"valid_nif="216860180"am_i_a_dead_ass_valid_nif(invalid_nif)# falseam_i_a_dead_ass_valid_nif(valid_nif)# true# Lets generate a valid NIF# Valid initials values are: "1, 2, 3, 5, 6, 8, 9"generate_dead_ass_valid_nif(initial_value=1)generate_dead_ass_valid_nif(initial_value=4)# Raise exception
Package: nigeria-bank-algos
NUBAN (Nigerian Uniform Bank Account Number) AlgorithmThis library is an algorithm for generating and validating a NUBAN (Nigeria Uniform Bank Account Number) in python. The algorithm is based on CBN specification for the 10-digit NUBAN.A common application of this algorithm in Nigeria today is to cut down the list of banks on USSD interfaces from about 23 to less than 5 after the user enters their bank account number (NUBAN). This comes in handy because a USSD screen can display at most, 160 characters at a time.How to use itpip install nigeria-bank-algoAPI Endpointsfrom banks.getbanks import *bnk = GetBank()likely = bnk.GetLikeBank(accountNumber='your-account-number')
print(likely)[
{'code': '044', 'name': 'ACCESS BANK'},
{'code': '070', 'name': 'FIDELITY BANK'},
{'code': '011', 'name': 'FIRST BANK OF NIGERIA'},
{'code': '058', 'name': 'GUARANTY TRUST BANK'},
{'code': '033', 'name': 'UNITED BANK FOR AFRICA'}
]A list of banks where the account number may likely domiciled will be return.
Package: nigeria-banks
📦 nigeria_banksNigeria Banks is a basic python package that returns details of particular bank in Nigeria.InstallationYou can install nigeria_banks fromPyPI:pip install nigeria_banksMake API Requesthttps://nigeria-banks.onrender.comHow to use$ from nigeria_banks.bank import getBank
# get bank details using ussd_code
get_bank = getBank(ussd_code="*945#")
# result = {'bank_code': '000017', 'cbn_code': '035', 'name': 'Wema Bank', 'bank_short_name': 'wema', 'ussd_code': '*945#', 'logo': 'https://nigeria-banks.onrender.com/static/images/wema.png'}

# get bank details using bank_code
get_bank = getBank(bank_code="000017")
# result = {'bank_code': '000017', 'cbn_code': '035', 'name': 'Wema Bank', 'bank_short_name': 'wema', 'ussd_code': '*945#', 'logo': 'https://nigeria-banks.onrender.com/static/images/wema.png'}

# get bank details using cbn_code
get_bank = getBank(cbn_code="035")
# result =  {'bank_code': '000017', 'cbn_code': '035', 'name': 'Wema Bank', 'bank_short_name': 'wema', 'ussd_code': '*945#', 'logo': 'https://nigeria-banks.onrender.com/static/images/wema.png'}

# get bank details using name
get_bank = getBank(name="wema")
# result = {'bank_code': '000017', 'cbn_code': '035', 'name': 'Wema Bank', 'bank_short_name': 'wema', 'ussd_code': '*945#', 'logo': 'https://nigeria-banks.onrender.com/static/images/wema.png'}
Package: nighres
NighresNighres is a Python package for processing of high-resolution neuroimaging data.
It developed out ofCBS High-Res Brain Processing Toolsand aims to make those
tools easier to install, use and extend. Nighres now includes new functions from
theIMCN imaging toolkitand
additional packages may be added in future releases.Because parts of the package have to be built locally it is currently not possible to
usepip installdirectly from PyPI. Instead, please follow the installation
instructions provided athttp://nighres.readthedocs.io/en/latest/installation.htmlCurrently, Nighres is developed and tested on Linux Ubuntu Trusty and Python 3.5.
Release versions have been extensively tested on our example data. Development
versions include additional modules and functions but with limited guarantees.Required packagesIn order to run Nighres, you will need:python >= 3.5Java JDK >= 1.7JCC >= 3.0For instance, in Debian/Ubuntu (amd64 systems):sudo apt-get install openjdk-8-jdk
export JCC_JDK=/usr/lib/jvm/java-8-openjdk-amd64
python3 -m pip install jcc    (or just pip install jcc if Python 3 is your default)For some functionalities you need extra packagesNipype & ANTs (for registration using ANTs)Pandas (for working with surface meshes)Nilearn (for plotting in the examples)If you use nighres, please reference the publictation:Huntenburg JM, Steele CJ, Bazin P-L (2018) Nighres: processing tools for high-resolution neuroimaging. Gigascience 7 Available at:https://academic.oup.com/gigascience/article/7/7/giy082/5049008DockerTo quickly try out nighres in a preset, batteries-included environment, you can use the
included Dockerfile, which includes Ubuntu 14 Trusty, openJDK-8, nighres, and Jupyter
Notebook. The only thing you need to install isDocker, a
lightweight container platform that runs on Linux, Windows and Mac OS X.To build the Docker image, do the following:git clone https://github.com/nighres/nighres
cd nighres
docker build . -t nighresTo run the Docker container:docker run --rm -p 8888:8888 nighresNow go with your browser tohttps://localhost:8888to start a notebook. You should be able
to import nighres by entering:import nighresinto the first cell of your notebook.Usually you also want to have access to some data when you run nighres. You can grant the Docker container
access to a data folder on your host OS by using the-vtag when you start the container:docker run --rm -v /home/me/my_data:/data -p 8888:8888 nighresNow, in your notebook you will be able to access your data on the path/data
Package: nightflight
nightflightThis is a very small library that leverages the astral package to calculate how
much of a flight occurs during regulatory night time (30 minutes before sunset to
30 minutes after sunrise).This calculation is somewhat complicated because sunset and sunrise are a
function of location, and location is changing rapidly during a flight.Positions and times during the flight are approximated by assuming that the
flight follows a great circle track between origin and destination and that
velocity is constant throughout.The latter assumption is likely the greatest source of error, since average
velocity along the great circle track will be much lower during the initial and
terminal manoeuvring phases.The assumption of great circle track may also be erroneous on very long
trips. If a trip starts on exactly opposite sides of the planet, there are an
infinite number of equally efficient tracks to choose from, so when the
situation is close to this, the actual track flown may end up being radically
different from that assumed.The main function takes n_vectors (vectors normal to the tangent plane at a
given location) as arguments to avoid dealing with singularities. A database of
n_vectors for airfields as designated by their three letter IATA code is
included. This data is a processed version of the database generously provided
by openflights.org (seehttps://openflights.org/data.html). Themake_locationsmodule has ato_nvecfunction to convert an arbitrary latitude and longitude
to an n_vector .
Package: nightly
NightlyNightly is a simple utility for executing a command every evening. Think of it as a poor person's Cron that only does one thing with a less-flexible scheduling system. I built this to handle kicking off automated scripts inside a few Docker projects.Requirements:Python 3.6+Python pipInstallation:pipinstallnightlyUsage:The following will run/path/to/script.shevery day at 4am:# nightly --when 4:00 /path/to/script.sh
Package: nightly-opentf-agent
opentf-agentThis package is part of the OpenTestFactory initiative.OverviewAn agent is a process that runs on an execution environment.  That process will contact the orchestrator at regular intervals, looking for some orders to execute. If there is a pending order, the agent will do as asked and send the result back to the orchestrator.The agent documentation is part of theOpenTestFactory orchestratordocumentation, in theGuidessection.LicenseCopyright 2021, 2023 Henix, henix.frLicensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: nightpro-for-gopro
NightPro for GoProRun nightpro to automatically make nightlapse videos from your GoPro's nightlapse images.$ nightpro -i <input_folder> -o <output_name> -s <size> -r <rate>input_folder: optional, default to current folderoutput_name: optional, default nightpro, do not include .mp4 in the namesize: optional, default full sizerate: optional, default 32Installationpip3 install nightpro-for-goproMaunal InstallationClone this repository, then run this from the repository's directory.python3 setup.py installffmpegNightPro is a wrapper for thisffmpegcommand, which turns a series of images into a timelapse video. Nightpro defaults much of this command and automatically finds the start numbers for you. That way to run the command below multiple times, you only have to runnightproonce.$ ffmpeg -r 32 -start_number <number> -i ./<folder>/G00%d.JPG -vcodec libx264 -pix_fmt yuv420p <name>.mp4Replace32with any framerate you'd likeReplace<number>with the number of the first photo, this is prefaced withG00in-i, add or remove zeros if your numbers are lower or higherReplace<folder>with the name of the folder the photos are inReplace<name>with the name of the output file-vcodec libx264 -pix_fmt yuv420pensures compatability with QuicktimeWhen testing add-s 640x480before the output name to make a smaller file size and process faster
Package: nightwalker
nightwalkernightwalker is a Python based library, that helps Deep / Machine Learning specialists to track their models during training without accessing server, and getting notifications full of their desired information via nightwalker App.PROSEasy to install and useTakes Steps, Epochs, Train & Test Loss, Acc as arguments so you can have all useful metrics in your appNo registration required, just take the unique code after walker.UID generates it for you, and share it with any number of co-workers to add the model to their appsUsed Frameworks & LibrariesAFS is built totally on Python & Node.JS.Python 3- for library buildingNode.JS- for Back-EndInstallationPython 3.6+ required to use.Get the package fromPyPi$pipinstallnightwalkerUsageImport the nightwalker and reach 'walker' function.Define the walker function inside the training loop, and pass the arguments.$fromnightwalkerimportwalker



$walker(arg1,arg2)After executing the training loop, the library will generate and print unique id for you, by which you'll then verify your session within the app.It'll look like this:$YouruniqueIDis---1sy45kd9Add new model to your app using the generated unique id.Arguments$iterationargumentisforcountingiterations.type=number.$itercountargumentisbasicallyadivider,foreveryhowmanyiterationsdoyouneedtosendthemetricupdate.type=number.$maxiterisamaximumofiterations,afterwhichthemodelfinishestraining.type=number.$epochcountsepochs.type=number.$maxepochisamaximumnumberofepochs,afterwhichnightwalkerwilldecidethemodelhadfinishedtraining.$testlosstakestestlossasametric.type=number.$trainlosstakesvalidationlossasametric.type=number.$acctakesaccuracyasametric.type=number.SuggestionsIn case you have any suggestions how to improve the app and library functionalities for you, please feel free to open new Issue, or contact us atCONTACT@SYSTEMCORP.AILicenseBSD 3-Clause Licence
Package: nightwatch
Nightwatch Logger is a Python package that offers a versatile logging utility for Python applications. It simplifies log management by providing features for both file and console output. You can use this package to improve your application’s logging capabilities with ease.FeaturesLog messages to files and optionally to the console.Supports various log levels: DEBUG, INFO, WARNING, ERROR, and CRITICAL.Customize log file names and log levels according to your application’s needs.Properly formats log entries with timestamps and log levels for clarity.Handles structured logging with dynamic data, including dictionaries, lists, strings, integers, floats, booleans, and None.Exception handling to gracefully manage errors during logging and message formatting.UsageImport the packagefrom nightwatch import NightwatchCreate an instance of the Nightwatch classnightwatch = Nightwatch(log_file_name=’app.log’, log_level=logging.INFO)LicenseThis project is licensed under the MIT License.
Package: nightwatch-chat
NightwatchThe chatting application to end all chatting applications.InstallationAs an end-user, you have multiple clients to pick from when it comes to accessing Nightwatch.Here are two of the standard clients for you to choose from:Urwid-based TUI clientInstallation is as simple aspip install nightwatch-chat.The client can be started by runningnightwatchin your terminal.Tauri-based desktop clientDownload the latest release for your system fromhere.Alternatively, run it manually:InstallRust.Follow theTauri prerequisites.Install the Tauri CLI:cargo install tauri-cli.Launch viacargo tauri devinside thenightwatch/desktop/folder.Server InstallationRunning a Nightwatch server can be a bit trickier then running the client, but follow along:You'll need eitherCPython 3.10 or above, orpreferably,PyPy 3.10.Install the following dependencies:pypy3 -m pip install ujson socketify.Launch the server viapypy3 -m nightwatch.server.For more possible ways to run the server, please refer to thesocketify.py documentation.ConfigurationConfiguration is available at:*nix systems: ~/.config/nightwatch/config.jsonWindows: %AppData%\Local\Nightwatch\config.jsonThe Nightwatch client currently allows you to store custom colors and username data there.The server currently only uses it forserver.name. Although that is prone to change.