Saravanan666/pypi-org huggingface dataset:
Package: nia
NIANIA is a python package for Nature Inspired Optimization Algorithms which makes optimization process easy and fast.InstalationCheckNIA's PyPI pageor simply install it using pip:pip install niaUsageSolve Ackley problem using Genetic Algorithm:fromnia.algorithmsimportGeneticAlgorithmfromnia.problemsimportackleynia=GeneticAlgorithm(cost_function=ackley,lower_bond=[-5,-5],upper_bond=[5,5],)nia.run()print(nia.message);output:quit criteria reached best answer is: [-0.02618036 -0.03615453] and best fitness is: 0.0006327163637145361 iteration : 11Plot:Customization:fromnia.algorithmsimportGeneticAlgorithm# Specific selection, crossover and muttion algorithms are available under related sub-packages.fromnia.selectionsimportTournamentfromnia.crossoversimportRandomSBXfromnia.mutationsimportUniformimportnumpyasnpdefackley(X):x=X[0]y=X[1]return-20*np.exp(-0.2*np.sqrt(0.5*(x**2+y**2)))-np.exp(0.5*(np.cos(2*np.pi*x)+np.cos(2*np.pi*y)))+np.e+20deflog(ga):print(ga.best)lower=np.array([-5,-5])upper=np.array([5,5])nia=GeneticAlgorithm(cost_function=ackley,iteration_function=log,lower_bond=lower,upper_bond=upper,quit_criteria=0.0001,num_variable=2,num_population=20,max_iteration=100,crossover=RandomSBX(2),mutation=Uniform(0.05),selection=Tournament(20))nia.run()print(nia.message);outputmax iteration reached best answer so far: [-0.02618036 -0.03615453] with best fitness: 0.1786046633597529 iteration : 99Supported Algorithms :Genetic algorithm (GeneticAlgorithm)Differential EvolutionEvolutionary ProgrammingArtificial Immune SystemClonal Selection AlgorithmBiogeography-basedSymbiotic Organisms SearchAnt Colony OptimizationArtificial Bee Colony (ArtificialBeeColony)Moth Flame Optimization AlgorithmCuckoo SearchGreen Herons Optimization AlgorithmBat AlgorithmWhale Optimization AlgorithmKrill HerdFish-swarm AlgorithmGrey Wolf OptimizerShuffle frog-leaping AlgorithmCat Swarm OptimizationFlower Pollination AlgorithmInvasive Weed OptimizationWater Cycle AlgorithmTeaching–Learning-Based OptimizationParticle Swarm Optimization (ParticleSwarmOptimization)Simulated Annealing AlgorithmGravitational Search AlgorithmBig Bang - Big CrunchSupported Selection Operators :Rank (Rank)Tournament (Tournament)Supported Cross Over Operators :K-Point (KPoint)SBX (SBX)Random SBX (RandomSBX)Supported Mutation Operators :Uniform (Uniform)
Package: niacin
niacinA Python library for replacing the missing variation in your text data.Why should I use this?Data collected for model training necessarily undersamples the likely
variance in the input space. This library is a collection of tools for
inserting typical kinds of perturbations to better approximate population
variance; and, for creating similar-but-incorrect examples to aid in
reducing the total size of the hypothesis space. These are commonly known as
ENRICHMENT and NEGATIVE SAMPLING, respectively.How do I use this?Functions in niacin are separated into submodules for specific data types.
Functions expose a similar API, with two input arguments: the data to be
transformed, and the probability of applying a specific transformation.enrichment:fromniacin.textimportendata="This is the song that never ends and it goes on and on my friends"print(en.add_misspelling(data,p=1.0))This is teh song tath never ends adn it goes on anbd on my firendsnegative sampling:fromniacin.textimportendata="This is the song that never ends and it goes on and on my friends"print(en.add_hypernyms(data,p=1.0))This is the musical composition that never extremity and it exit on and on my personHow do I install this?withpip:pipinstallniacinfrom source:gitclonegit@github.com:deniederhut/niacin.git&&cdniacin&&pythonsetup.pyinstallIf you have installedniacinfrom source, you can run the test suite to verify that
everything is working properly. We usepytest,
which you will first need to install:pipinstallpytestthen you can run the library's tests withpytest-m'not slow'if you would like to see the coverage report, you can do so withpytest-covlike so:pipinstallpytest-cov
pytest-m'not slow'--cov=niacin&&coveragehtmlHow can I install the optional dependencies?If you want to use the backtranslate functionality, niacin will need pytorch and some other
libraries. These can be installed as extras with:pipinstallniacin[backtranslate]If you are on macos, this might fail with a warning about your version of gcc:Your compiler (g++) is not compatible with the compiler Pytorch was
built with for this platform, which is clang++ on darwin.You can avoid this error by executing the following:CFLAGS='-stdlib=libc++'pipinstallniacin[backtranslate]
Package: niaclass
NiaClass is a framework for solving classification tasks using nature-inspired algorithms. The framework is written fully in Python. Its goal is to find the best possible set of classification rules for the input data using theNiaPy framework, which is a popular Python collection of nature-inspired algorithms. The NiaClass classifier supports numerical and categorical features.Free software:MIT license,Documentation:https://niaclass.readthedocs.io/en/latest/,Python versions:3.7.x, 3.8.x, 3.9.x.Installationpip3Install NiaClass with pip3:pip3installniaclassIn case you would like to try out the latest pre-release version of the framework, install it using:pip3installniaclass--preFedora LinuxTo install NiaClass on Fedora, use:$dnfinstallpython-niaclassFunctionalitiesBinary classification,Multi-class classification,Support for numerical and categorical features.ExamplesUsage examples can be foundhere.Reference Papers (software is based on ideas from):[1] Iztok Fister Jr., Iztok Fister, Dušan Fister, Grega Vrbančič, Vili Podgorelec.On the potential of the nature-inspired algorithms for pure binary classification. In. Computational science - ICCS 2020 : 20th International Conference, Proceedings. Part V. Cham: Springer, pp. 18-28. Lecture notes in computer science, 12141, 2020LicenceThis package is distributed under the MIT License. This license can be found online athttp://www.opensource.org/licenses/MIT.DisclaimerThis framework is provided as-is, and there are no guarantees that it fits your purposes or that it is bug-free. Use it at your own risk!Cite usPečnik L., Fister I., Fister Jr. I. (2021) NiaClass: Building Rule-Based Classification Models Using Nature-Inspired Algorithms. In: Tan Y., Shi Y. (eds) Advances in Swarm Intelligence. ICSI 2021. Lecture Notes in Computer Science, vol 12690. Springer, Cham.
Package: niagara
NiagaraNiagara is a ricing tool made for Linux systems. It aims to be a universal tool that can be used on multiple distributions, as it does not rely on a singular package manager. Niagara manages configs by taking a JSON file that contains some fields such aspackages,dotfile,wallpaper, etc.How does Niagara handle packages?Niagara has a list of packages that you can place inside the configuration file, and then it goes and checks it against the corresponding package for your linux distribution. A good example would be the following:{"name":"doas","arch":"opendoas","void":"opendoas","fedora":"opendoas","gentoo":"app-admin/doas"}This allows us to support multiple distributions, whilst making it awrite once, run anywherestyle of program.Featurespackagesconfigwallpaperdotfilescriptscommandsavailable to clone and use a git repository as the basis for commandsoption to run the command in a specified directoryxinitrc generationExample configuration{"packages":["sway","feh","picom","i3","kitty"],"config":[{"option":"wallpaper","val":"https://github.com/kavulox/dotfiles/raw/master/wallpapers/forest.jpg"},{"option":"dotfile","val":["https://github.com/kavulox/nvim","https://github.com/kavulox/picom"]},{"option":"scripts","val":[{"method":"curl","url":"https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh"}]}],"source":[{"link":"https://git.suckless.org/dwm","cmds":[{"dir":"dwm","cmd":"sudo make clean install"}]}],"xinitrc":["picom -b","exec dwm"]}ContributingNew contributors should submit a PR with a short description of their changes.ArtixLabsJoin our discord server athttps://discord.gg/ajNswSyf6qJoin our Matrix space athttps://matrix.to/#/#artixlabs:halogen.cityTodoGet more packages.Make packages support multiple package managers.Split deps.py into multiple files.Add documentation.Add checks to see if a specified package is not natively available for a distribution, then to refer to a custom build option.AuthorNiagarawas written by kavulox
Package: nialog
IntroductionSimple package/script to setupJSONlogging for a Python app or script.
Usespython-json-loggerand
is mostly just a wrapper around it. Instead of adding this script to every
Python module that I/you create you can just add this as a dependency and call:fromnialogimportsetup_module_logging,LoggingLevel# Default logging level is WARNINGsetup_module_logging()# LoggingLevel has enums for default logging module levels# Can be used with e.g. typer as command-line inputsLoggingLevel.DEBUG.value=="DEBUG"# = TrueRunning testsTo run pytest in currently installed environment:poetryrunpytestTo run test suite best suited for before pushing to e.g. GitHub.poetryruninvokeprepushTo run full extensive test suite:poetryruninvoketestFormatting and lintingFormatting and linting is done with a single command. First formats,
then lints.poetryruninvokeformat-and-lintBuilding docsDocs can be built locally to test thatReadTheDocscan also build them:poetryruninvokedocsInvoke usageTo list all available commands fromtasks.py:poetryruninvoke--listDevelopmentDevelopment dependencies include:invokenoxcopierpytestcoveragesphinxBig thanks to all maintainers of the above packages!LicenseCopyright © 2021, Nikolas Ovaskainen.
Package: niaopendata
niaopendata is a Python client library for accessing theNorthern Ireland Assembly Open Data API. niaopendata has a full test suite and aims to have 100% coverage of the API. Tests exist both to ensure that the library is working as expected, and also that the library complies with and fully implements the API specification.niaopendata supports Python 2.6, 2.7, PyPy, 3.3 and 3.4 (and probably later versions too, but I haven’t tested on those).Free software: MIT licenseDocumentation:https://github.com/paddycarey/niaopendataInstallationDistribute & PipInstalling niaopendata is simple withpip:$ pip install niaopendataor, witheasy_install:$ easy_install niaopendataBut, you reallyshouldn’t do that.Get the Codeniaopendata is actively developed on GitHub, where the code isalways available.You can either clone the public repository:$ git clone git://github.com/paddycarey/niaopendata.gitOr download thetarball:$ curl -OL https://github.com/paddycarey/niaopendata/tarball/masterOnce you have a copy of the source, you can embed it in your Python package, or install it into your site-packages easily:$ python setup.py installUsageniaopendata aims to provide a simple, pythonic interface to Northern Ireland Assembly Open Data API. It has been designed to be easy to use, and aims to provide full coverage of the API with a consistent interface.First you’ll need to import niaopendata.:import niaopendataRetrieving data from the APIAs an example of what is possible, it is easy to retrieve a list of all members.:>>> niaopendata.all_current_members()
[
    OrderedDict([
        (u'PersonId', u'307'),
        (u'AffiliationId', u'2482'),
        (u'MemberName', u'Agnew, Steven'),
        (u'MemberLastName', u'Agnew'),
        (u'MemberFirstName', u'Steven'),
        (u'MemberFullDisplayName', u'Mr S Agnew'),
        (u'MemberSortName', u'AgnewSteven'),
        (u'MemberTitle', u'MLA - North Down'),
        (u'PartyName', u'Green Party'),
        (u'PartyOrganisationId', u'111'),
        (u'ConstituencyName', u'North Down'),
        (u'ConstituencyId', u'11'),
        (u'MemberImgUrl', u'http://aims.niassembly.gov.uk/images/mla/307_s.jpg'),
        (u'MemberPrefix', u'Mr')
    ]),
    ...
]

>>> len(niaopendata.all_current_members())
107Full API documentationFull documentation is a work in progress, but the code itself should be easy to follow. All public functions are explicitly imported in__init__.pyand all functions have appropriate docstrings.Testingniaopendata has a full test suite. Assuming you have a full source checkout of the niaopendata repository, running the tests is simple withtox:$ pip install tox
$ toxIt is recommended that you use a virtualenv when developing or running the tests to ensure that system libraries do not interfere with the tests.TIP:If you’re using Ubuntu, you can find older/newer versions of python than the one shipped with your distributionhere. You can install as many as you like side by side without affecting your default python install.Copyright & LicenseCopyright © 2015 Patrick Carey (https://github.com/paddycarey)Licensed under theMITlicense.
Package: niapi
ProjectStatusCI/CDPackageQualityCommunityMetaniapi- Network Information APITable of ContentsAboutInstallationUsageContributingContributorsLicenseAcknowledgementsScreenshotsAboutInstallationpip install niapiUsageInstall the project:pip install -e .Run the project:NOTE:From within the virtual environmentapp run -r --debugUsing the CLI:#viacurl➜ curl --request GET \--url 'http://0.0.0.0:8000/calculator/ip?ip=4.8.15.16&prefix=23' \--header 'Content-Type: application/json'#viaAppCLI#TODOapp calculate "10.248.15.39/29"Using the APIBrowse to:SwaggerElementsUse the auto-generated API docs to interact with the APIFrom around the web:Browse tohttps://niapi.app/and use the front page form, API, orcurlto interact with the API.ContributingSeeCONTRIBUTING.rstfor more information.Start the app:app run-allStart the TailwindCSS watcher:tailwindcss -i niapi/domain/web/resources/input.css -o niapi/domain/web/resources/style.css --watchContributorsLicenseMITAcknowledgementsBuilt on Litestar and PydanticUsinghttps://feathericons.dev/Using TailwindCSSScreenshots
Package: nibabel
CodeTestsPyPIPackagesLicense & DOIRead and write access to common neuroimaging file formats, including:ANALYZE(plain, SPM99, SPM2 and later),GIFTI,NIfTI1,NIfTI2,CIFTI-2,MINC1,MINC2,AFNI BRIK/HEAD,ECATand Philips PAR/REC.
In addition, NiBabel also supportsFreeSurfer’sMGH, geometry, annotation and
morphometry files, and provides some limited support forDICOM.NiBabel’s API gives full or selective access to header information (metadata),
and image data is made available via NumPy arrays. For more information, see
NiBabel’sdocumentation siteandAPI reference.InstallationTo install NiBabel’scurrent releasewithpip, run:pip install nibabelTo install the latest development version, run:pip install git+https://github.com/nipy/nibabelWhen working on NiBabel itself, it may be useful to install in “editable” mode:git clone https://github.com/nipy/nibabel.git
pip install -e ./nibabelFor more information on previous releases, see therelease archiveordevelopment changelog.TestingDuring development, we recommend usingtoxto run nibabel tests:git clone https://github.com/nipy/nibabel.git
cd nibabel
toxTo test an installed version of nibabel, install the test dependencies
and runpytest:pip install nibabel[test]
pytest --pyargs nibabelFor more information, consult thedeveloper guidelines.Mailing ListPlease send any questions or suggestions to theneuroimaging mailing list.LicenseNiBabel is licensed under the terms of theMIT license.
Some code included with NiBabel is licensed under theBSD license.
For more information, please see theCOPYINGfile.CitationNiBabel releases have aZenodoDigital Object Identifier(DOI) badge at
the top of the release notes. Click on the badge for more information.
Package: nibabies
Magnetic resonance imaging (MRI) requires a set of preprocessing steps before
any statistical analysis. In an effort to standardize preprocessing,
we developedfMRIPrep(a preprocessing tool
for functional MRI, fMRI), and generalized its standardization approach to
other neuroimaging modalities (NiPreps). NiPreps
brings standardization and ease of use to the researcher, and effectively
limits the methodological variability within preprocessing. fMRIPrep is designed
to be used across wide ranges of populations; however it is designed for (and
evaluated with) human adult datasets. Infant MRI (i.e., 0-2 years) presents
unique challenges due to head size (e.g., reduced SNR and increased partial
voluming and rapid shifting in tissue contrast due to myelination. These and
other challenges require a more specialized workflow.NiBabies, an open-source
pipeline extending from fMRIPrep for infant structural and functional MRI
preprocessing, aims to address this need.The workflow is built atopNipypeand encompases a large
set of tools from well-known neuroimaging packages, includingFSL,ANTs,FreeSurfer,AFNI,Connectome Workbench,
andNilearn.
This pipeline was designed to provide the best software implementation for each state of
preprocessing, and will be updated as newer and better neuroimaging software becomes
available.NiBabiesperforms basic preprocessing steps (coregistration, normalization, unwarping,
segmentation, skullstripping etc.) providing outputs that can be
easily submitted to a variety of group level analyses, including task-based or resting-state
fMRI, graph theory measures, surface or volume-based statistics, etc.NiBabiesallows you to easily do the following:Take fMRI data fromunprocessed(only reconstructed) to ready for analysis.Implement tools from different software packages.Achieve optimal data processing quality by using the best tools available.Generate preprocessing-assessment reports, with which the user can easily identify problems.Receive verbose output concerning the stage of preprocessing for each subject, including
meaningful errors.Automate and parallelize processing steps, which provides a significant speed-up from
typical linear, manual processing.RepositoryDocumentation
Package: nibabies-wrapper
The NiBabies Docker/Singularity wrapperNiBabies is a functional magnetic resonance image pre-processing pipeline
optimized for infant and neonate MRI. It is designed to provide an easily
accessible, state-of-the-art interface that is robust to differences in
scan acquisition protocols and that requires minimal user input, while
providing easily interpretable and comprehensive error and output reporting.This is a Python wrapper to run NiBabies.
It generates the appropriate Docker or Singularity commands, providing an
intuitive interface to running the fMRIPrep workflow in whichever environment.
Docker or Singularity must be installed, and in the case of Docker, running.
Installations can be check by runningdocker info  # Docker
singularity version  # SingularityPlease report any feedback to ourGitHub repositoryand do not
forget tocreditall
the authors of software that NiBabies uses.UsageExample Docker usagenibabies-wrapper docker <data-path> <output-path> participant <nibabies-arguments>Example Singularity usagenibabies-wrapper singularity <data-path> <output-path> participant -i <img-path> <nibabies-arguments>
Package: nibarchive
NIBArchive-ParserParser implementation of NeXTSTEP Interface Builder (NIB) files in Python3.NIBArchiveThe.nibfile is primarily associated with Interface Builder, a graphical user interface (GUI) design tool used to
create the visual layout of user interfaces for applications. The purpose of a NIB file is to store the information
about the user interface elements, their properties, and their relationships with each other.The file format has been described in detail in thenibsqueezerepository.InstallationJust use pip:$pipinstallnibarchiveand to build the docs you needmaketo be installed:$pipinstall-rdocs/requirements.txt$cddocs&&makehtmlUsageThe python package provided with this repository supports parsing NIB archives into an object model. More detailed information about the implementation and fields of each class, please refer to the documentation available onGithub-Pages.Parsing NIB filesAs theNIBArchiveParseronly acceptsIOBaseobjects, we can either parse opened files directly or useio.BytesIOfor a reader on existing byte structures.fromnibarchiveimportNIBArchiveParser# Create the parser instanceparser=NIBArchiveParser(verify=True)# Parse an input file from scratchwithopen("path/to/file.nib","rb")asfp:archive:NIBArchive=parser.parse(fp)Or withBytesIO:fromioimportBytesIO# assue the file content is stored herebuffer=bytes(...)parser=NIBArchiveParser()# parse using BytesIO wrapper classarchive=parser.parse(BytesIO(buffer))Working with NIBArchive objectsAt this point we can use the returned object to inspect the files content.But, the parser doesnotorganize the returned archive, so we have to do it afterwards:# Get an objectobj:NIBObject=archive.objects[0]# Get the object's class nameclass_name:ClassName=archive.get_class_name(obj)# Retrieve the object's valuesvalues:list[NIBValue]=archive.get_object_values(obj)forvalueinvalues:# Each value is mapped to a NIBKeykey:NIBKey=archive.get_value_key(value)There is a convienient method namedget_object_itemswhich automatically maps all values of an object to their corresponding keys. The return value is of typedict[NIBKey, NIBValue]LicenseDistributed under the GNU GPLv3. SeeLICENSEfor more information.
Package: nibble
nibble======.. image:: https://img.shields.io/pypi/status/nibble.svg:target: https://pypi.python.org/pypi/nibble.. image:: https://img.shields.io/pypi/v/nibble.svg:target: https://pypi.python.org/pypi/nibble.. image:: https://img.shields.io/pypi/pyversions/nibble.svg:target: https://pypi.python.org/pypi/nibble.. image:: https://travis-ci.org/gebn/nibble.svg?branch=master:target: https://travis-ci.org/gebn/nibble.. image:: https://coveralls.io/repos/github/gebn/nibble/badge.svg?branch=master:target: https://coveralls.io/github/gebn/nibble?branch=master.. image:: https://landscape.io/github/gebn/nibble/master/landscape.svg?style=flat:target: https://landscape.io/github/gebn/nibble/masterSpeed, distance and time calculations around quantities of digital information. Coming soon.Installation------------::$ pip install nibbleDemo----.. code-block:: pythonfrom nibble.information import Informationfrom nibble.duration import Durationfrom nibble.speed import Speedinformation = Information(1, Information.GIBIBYTES)print('{0}'.format(information))               # '1 GiB'print('{0:GB}'.format(information))            # '1.07GB'print('{0: GB}'.format(information))           # '1.07 GB'print('{0:,.2f| Mb}'.format(information))      # '8,589.93 Mb'speed = Speed(Information(20, Information.MEGABITS), Duration.SECOND)print('{0}'.format(speed))                     # '2.38 MiB/s'print('{0:Mb}'.format(speed))                  # '20Mb/s'print('{0: Gb/w}'.format(speed))               # '12,096 Gb/w'print(Speed.TEN_GIGABIT / 10== Speed.HUNDRED_MEGABIT * 10== Speed.GIGABIT)                        # Trueprint('{0: dB/y}'.format(Speed.TEN_GIGABIT))   # '39.42 PB/y'print('{0:.2f| bB/mo}'.format(Speed.GIGABIT))  # 298.77 TiB/mo
Package: nibble-coding
Python package implementing nibble and byte coding.How do I install this package?As usual, just download it using pip:pipinstallnibble_codingTests CoverageSince some software handling coverages sometime get slightly different results, here’s three of them:Usage examplesfromnibble_codingimportnibble_coding,byte_codingbyte_coding(0)# 10000000byte_coding(40)# 10101000byte_coding(80)# 11010000byte_coding(120)# 11111000byte_coding(160)# 0000000110100000byte_coding(200)# 0000000111001000byte_coding(240)# 0000000111110000byte_coding(280)# 0000001010011000byte_coding(320)# 0000001011000000byte_coding(360)# 0000001011101000nibble_coding(0)# 1000nibble_coding(1)# 1001nibble_coding(2)# 1010nibble_coding(3)# 1011nibble_coding(4)# 1100nibble_coding(5)# 1101nibble_coding(6)# 1110nibble_coding(7)# 1111nibble_coding(8)# 00011000nibble_coding(9)# 00011001nibble_coding(10)# 00011010nibble_coding(11)# 00011011nibble_coding(12)# 00011100nibble_coding(13)# 00011101nibble_coding(14)# 00011110nibble_coding(15)# 00011111
Package: nibbler-python
nibbler-python helps you parse for valid email addresses in Python projectsExample Usagefrom nibbler.parser import parse_email# valid email
parse_email(‘“much.more unusual”@example.com’)# invalid email
parse_email(‘Abc.example.com’)ContributeThis library is hosted on Github and you can contribute there:https://github.com/sendgridlabs/nibbler-python