Saravanan666/pypi-org huggingface dataset:
Package: near-seed-phrase-py
NEAR Seed PhrasePython tool for creating and converting mnemonic-phrases, public key and private key for NEAR accounts.🚨 Status: BETA, contributions welcome!Ported to Python fromhttps://github.com/near/near-seed-phraseInstallPoetrypoetryshellpoetryshow-v# copy this virtualenv path and set it as your Python interpreterpoetryaddnear-seed-phrase-pyPippipinstallnear-seed-phrase-pyUsagefromnear_seed_phrase.mainimportgenerate_seed_phrase,parse_seed_phrase# Generate a BIP39 seed phrase with its corresponding Keysgenerate_seed_phrase()Returns:{seed_phrase:str# BIP39 seed phrasesecret_key:str# ed25519 secret/private key, formatted for NEAR (e.g. "ed25519:[SECRET_KEY]")public_key:str# ed25519 public key, formatted for NEAR (e.g. "ed25519:[PUBLIC_KEY]")public_key_hex:str# lowercase hex representation of public_key that can be used as an implicit account ID; see https://docs.near.org/integrator/implicit-accounts}# Recover keys from a BIP39 seed phrase (returns same response as generate_seed_phrase())parse_seed_phrase(seed_phrase)
Package: nearside
[![Build status](https://ci.appveyor.com/api/projects/status/ccwuv424wao4rbly?svg=true)](https://ci.appveyor.com/project/rdireen/nearside)
[![Build Status](https://travis-ci.org/rdireen/nearside.svg?branch=master)](https://travis-ci.org/rdireen/nearside)
[![Coverage Status](https://coveralls.io/repos/rdireen/nearside/badge.svg?branch=master)](https://coveralls.io/r/rdireen/nearside?branch=master)NearSideBecause we make more sense than The Far Side.Description: a package for processing antenna near-field data.InstallUbuntu:NearSide uses NumPy so you need to decide if you want to build it yourself with$ sudo pip install numpyor download the package with$ sudo apt-get install python-numpyI have been building NumPy using the pip method, but it takes a long time.Once you have NumPy, install NearSide with$ sudo pip install nearside (COMMING SOON)Windows:Make sure you have Numpy on your machine, then$ pip install nearside (COMMING SOON)ContributingReporting bugs, suggesting features, helping with documentation, and adding to the code is very welcome. See
[Contributing](CONTRIBUTING.md).LicenseCopyright (C) 2015  Randy Direen <nearside@direentech.com>.
NearSide is licensed under GNU General Public License, version 3, a copy of this license has been provided within the COPYING file in this directory, and can also be found at <http://www.gnu.org/licenses/>.
Package: neataco
neataco is an Ant Colony Optimization algorithm written in pure python. The intention is
to use this package with PyPy. The hot loops in the algorithm are perfect for PyPy's
just-in-time compilation and results in very fast performance.To run create an instance of AntColonyOptimization and call run(). The output is a
list with the optimized sequence of input items.The input items can be a list of anything, because the distance function also
has to be provided. The distance function must be able to calculate the distance
between any items in the input list.An example:fromneatacoimportAntColonyOptimizationitems=[10,20,15,5,100,2,30,50]distance_fn=lambdaa,b:abs(b-a)aco=AntColonyOptimization(items,distance_fn,ant_count=1024,alpha=1,beta=20,evaporation=0.2,)optimal_path=aco.run()print(optimal_path)This will print the shortest path between all of the numbers; in this case ordering them.
Package: neatbio
neatbioA Simple Yet Another Bioinformatics Library for DNA,RNA and Protein SequencingInstallationpipinstallneatbioBenefitsHandling Sequences(DNA,RNA,Protein)Protein SynthesisSequence SimilarityKmers Generation and Kmer DistanceProbable Back Translation of Amino AcidsReading FASTA filesWhy NeatBio?NeatBio is yet another bioinformatics library along side powerful and popular bioinformatics libraries such as biopython,scikit-bio,biotite.It is meant to complement these powerful library in a simple way.UsageHandling SequencesNeatbio offers the ability to analyse sequences for more insight>>>importneatbioasnt>>>seq1=nt.Sequence('ATGCATTGA')>>>seq1.gc33.33333333333333>>>seq1.gc_frequency()3>>>seq1.at66.66666666666666>>>seq1.at_frequency()6>>>seq1.transcribe()'AUGCAUUGA'>>>mrna=seq1.transcribe()>>>nt.Sequence(mrna).back_transcribe()'ATGCATTGA'>>>>>>seq1.translate()'MH*'>>>seq1.translate>>>>>>rna_seq=nt.Sequence("AUGCAUUGA","RNA")>>>rna_seq.seqtype>>>Sequence(seq='AUGCAUUGA',seqtype='RNA')Working with Proteins>>>protein1=nt.ProteinSeq('MIT')>>>protein1ProteinSeq(seq='MIT')>>>protein1.back_translate()'ATGATAACT'Note that the back_translate() function offers a probable sequence and not the exact
back-translation as multiple codons can represent the same amino acids.Convert 3 Letter Amino Acid to 1 and vice versa>>>fromneatbio.sequtilsimportconvert_3to1,convert_1to3,get_acid_name>>>convert_3to1('Ala')'A'>>>convert_1to3('L')'Leu'>>>get_acid_name('Ala')'Alanine'Generate DotPlot>>>importneatbioasnt>>>importneatbio.sequtilsasutils>>>seq1=nt.Sequence('AGTCGTACT')>>>seq2=nt.Sequence('AGGCGCACT')>>>>>>utils.dotplot(seq1,seq2)|AGGCGCACT-----------A|■■G|■■■T|■C|■■■G|■■■T|■A|■■C|■■■T|■>>>Reading FASTA Files>>>importneatbioasnt>>>file1=nt.read_fasta('sequence.fasta')>>>file1['seqRecord']>>>seq1=nt.Sequence(file1['seqRecord'])DocumentationPlease read thedocumentationfor more information on what neatbio does and how to use is for your needs.More Features To Addsequence alignmentwriting FASTA filessupport for more file formatsAcknowledgementsInspired by packages like BioPython,Scikit-Bio and BiotiteNBContributions Are WelcomedNotice a bug, please let us know.Thanks A lotByJesse E.Agbe(JCharis)Jesus Saves @JCharisTech
Package: neatdend
IntroductionNEAT is a python library for the study, simulation and simplification of
morphological neuron models. NEAT accepts morphologies in thede factostandard .swc format[Cannon1998], and implements high-level tools to interact
with and analyze the morphologies.NEAT also allows for the convenient definition of morphological neuron models.
These models can be simulated, through an interface with the NEURON simulator[Carnevale2004], or can be analyzed with two classical methods:(i)the
separation of variables method[Major1993]to obtain impedance kernels as
a superposition of exponentials and(ii)Koch’s method to compute impedances
with linearized ion channels analytically in the frequency domain[Koch1985].
Furthermore, NEAT implements the neural evaluation tree framework[Wybo2019]and an associated C++ simulator, to analyze subunit independence.Finally, NEAT implements a new and powerful method to simplify morphological
neuron models into compartmental models with few compartments[Wybo2021]. For
these models, NEAT also provides a NEURON interface so that they can be
simulated directly, and will soon also provide a NEST interface[Gewaltig2007].DocumentationDocumentation is availablehereInstallationInstallNote: The following instructions are for Linux and Max OSX systems and only use
command line tools. Please follow the appropriate manuals for Windows systems or
tools with graphical interfaces.You can install the latest release via pip:pipinstallneatdendThe adventurous can install the most recent development version directly from our master branch (don’t use this in production unless there are good reasons!):gitclonegit@github.com:unibe-cns/NEAT.gitcdNEATpipinstall.Post-InstallTo use NEAT withNEURON, make sure NEURON
is properly installed with its Python interface. The easiest way to install NEURON
on Linux and macOS platform is via pip:pipinstallneuronSee detailedinstall instructions.You can test it by compiling and installing the default NEURON mechanisms by runningcompilechannelsdefaultTest the installationpytestReferences[Cannon1998]Cannon et al. (1998)An online archive of reconstructed hippocampal neurons, J. Neurosci. methods.[Carnevale2004]Carnevale, Nicholas T. and Hines, Michael L. (2004)The NEURON book[Koch1985]Koch, C. and Poggio, T. (1985)A simple algorithm for solving the cable equation in dendritic trees of arbitrary geometry, Journal of neuroscience methods, 12(4), pp. 303–315.[Major1993]Major et al. (1993)Solutions for transients in arbitrarily branching cables: I. Voltage recording with a somatic shunt, Biophysical journal, 65(1), pp. 423–49.[Martelli03]Martelli (2003)Python in a Nutshell, O’Reilly Media Inc.[Wybo2019]Wybo, Willem A.M. et al. (2019)Electrical Compartmentalization in Neurons, Cell Reports, 26(7), pp. 1759–1773[Wybo2021]Wybo, Willem A.M. et al. (2021)Data-driven reduction of dendritic morphologies with preserved dendro-somatic responses, eLife, 10:e60936, pp. 1–26[Gewaltig2007]Gewaltig, Marc-Oliver and Diesmann, Markus. (2007)NEST (NEural Simulation Tool), Scholarpedia, 2(4), pp. 1430
Package: neat-html
neat-htmlA python library for writing and composing HTML.Features:small API to learn (2 functions)fully typed APIproduces "neatly" formatted HTMLwritten in pure pythonzero dependenciescomprehensive test suiteno recursionInstall using pip:pipinstallneat-htmlTake it for a spin:>>>fromneat_htmlimporth,render>>>greeting=h("strong",{"style":{"color":"green"}},"Hello")>>>html=h("p",{"id":"foo"},[greeting,", World!"])>>>print(render(html))<pid="foo"><strongstyle="color: green">Hello</strong>,World!</p>
Package: neatlog
neatlog: A neat logging configurationThis package provides an easy and transparent way of customizing the builtin logging.
Just import the module and enjoy the difference.InstallationThe installation is straight forward. You can install the package viapip,pipenv,poetryand alike or by downloading the source from the gitlab repository.From pypi.org (recommended)Install by typingpipinstallneatlogorpipinstall--userneatlogif you do not have root access.Please check the documentations forpipenv, andpoetryfor information on how to install packages with these tools.From gitlab.com (for experts)To get the latest features or contribute to the development, you can clone the whole project usinggit:gitclonehttps://gitlab.com/szs/neatlog.gitUsageSimply import neatlog in your program and use logging as usually:importloggingfromlog_fmtimportset_log_levelset_log_level(logging.DEBUG)logging.critical("something critical")logging.error("some error")logging.warning("some warning")logging.info("some info")logging.debug("something for debugging")How to ContributeIf you find a bug, want to propose a feature or need help getting this package to work with your data
on your system, please don’t hesitate to file anissueor write
an email. Merge requests are also much appreciated!Project linksRepositoryDocumentationpypi page
Package: neatly
neatlyNOTE:neatlyis not yet functionalneatlyis a package designed to facilitate the implementation ofNeuroEvolution of Augmenting Topologies (NEAT)in Python.Installationneatlycan be installed with pip via:pipinstallneatlyUsage/ExampleConfigurationWhen usingneatly, although a config file isn't strictly necessary, it's highly highly recommended that you use one to streamlineneatly's implementation process. In the same folder as the python file that is using neatly functions, create aconfig.tomlfile. To get started, simply copy-paste this in:i_count=2# Number of inputso_count=1# Number of outputspop_size=30# Population size of a single generationThis is an extremely basicconfig.tomlfile, but it gets the job done. Feel free to adjust the default values in order to steerneatlyin the direction of your desired network/structure. There are many other useful parameters that can (and should) be tweaked, so make sure to check outHello, world!Here's an example of how to implement a very simpleneatlynetwork:importneatly# Initialize a population and sort into a list of extant speciespop=neatly.initialize_population()almanac=neatly.speciate(pop)For more details and tutorials, seeContributingTo be completely honest, I don't know why anybody would want to contribute to this pile of hot garbage, and I don't really know how contributing works, but if you're interested emailme.LicenseMIT
Package: neatmesh
neatmeshMesh Quality Inspectorneatmesh is a 2D/3D finite volume mesh quality inspector and a python library that computes cells volumes, face areas, centers, normals and many more. neatmesh works with all formats supported bymeshio.neatmesh is in early active development stage, and all sort of contributions are welcome (specially if you're new to open source contribution! ☺️)InstallationInstall with:pip install neatmeshUsageUsing neatmesh is simple:neatmesh my_awesome_mesh.su2orimport neatmesh as nm

mesh = nm.read('my_awesome_mesh.su2')
# mesh.face_areas, mesh.face_centers, mesh.owner_neighbor,
# mesh.n_points, mesh.n_edges, mesh.n_faces, .....What does neatmesh report?neatmesh will report file size, mesh bounding box, mesh dimensionality, points count, duplicate points count, face counts and types, cell counts and types, and the following quality statisticsFace Area: face area in mesh units.Face Aspect Ratio: ratio between max. and min. length of face bounding rectangle.Cell Volume: volume of 3D cell, current supported cell types: hexahedron, tetrahedron, wedge and pyramid.Non-Orthogonality: angle in degrees between (a) vector connecting two elements centers NP and (b) normal vector to the shared face or edge between the elementsSource:Introduction to Computational Fluid Dynamics: Governing Equations, Turbulence Modeling Introduction and Finite Volume Discretization Basics. - Joel GuerreroNeighbor Element Volume/Area Ratio: ratio between the volume (for 3D mesh) or area (for 2D mesh) of all neighboring cells, defined asmax_vol / min_volormax_area / min_area, so it's always greater than or equal 1.Quality Rulesneatmesh will look for a quality rule file in current working directory,neatmesh.tomlorquality.tomlormy_awesome_mesh.toml. A quality rule file sets maximum values for quality metrics calculated by neatmesh, for example this is the content of a typicalneatmesh.tomlfile:max_non_orhto = 50
max_face_aspect_ratio = 10
max_neighbor_volume_ratio = 3
max_neighbor_area_ratio = 3In case no quality rules file was present, neatmesh will use default max. values:max_non_orhto = 60
max_face_aspect_ratio = 20
max_neighbor_volume_ratio = 15
max_neighbor_area_ratio = 15
Package: neat-ml
Network Embedding All the Things (NEAT)NEAT is a flexible pipeline for:Parsing a graph serializationGenerating embeddingsTraining ClassifiersMaking predictionsCreating well formatted output and metrics for the predictionsQuick Startpip install neat-ml
neat run --config neat_quickstart.yamlNEAT will write graph embeddings to a newquickstart_outputdirectory.RequirementsThis pipeline hasgrapeas a major dependency.Methods fromtensorfloware supported, but are not installed as dependencies to avoid version conflicts.Please install the versions oftensorflow,CUDA, andcudnncompatible with your system and with each other prior to installing NEAT if you wish to use these methods.On Linux, this may be easiest usingcondaas follows:wget https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh -O anaconda.sh
bash ./anaconda.sh -b
echo "export PATH=\$PATH:$HOME/anaconda3/bin" >> $HOME/.bashrc
conda init
conda install cudnn
conda install tensorflowInstallationpip install neat-mlRunning NEATneat run --config tests/resources/test.yaml # example
neat run --config [your yaml]The pipeline is driven by a YAML file (e.g.tests/resources/test.yaml), which contains all parameters needed to complete the pipeline.
The contents and expected values for this file are defined by theneat-ml-schema.This includes hyperparameters for machine learning and also things like files/paths to output results.
Specify paths to node and edge files:GraphDataConfiguration:
  graph:
    directed: False
    node_path: path/to/nodes.tsv
    edge_path: path/to/edges.tsvIf the graph data is in a compressed file and/or a remote location (e.g., on KG-Hub), one or more URLs may be specified in thesource_dataparameter:GraphDataConfiguration:
  source_data:
    files:
      - path: https://kg-hub.berkeleybop.io/kg-obo/bfo/2019-08-26/bfo_kgx_tsv.tar.gz
        desc: "This is BFO, your favorite basic formal ontology, now in graph form."
      - path: https://someremoteurl.com/graph2.tar.gz
        desc: "This is some other graph - it may be useful."A diagram explaining the design a bit ishere.If you are uploading to AWS/S3,see here for configuring AWS credentials:CreditsDeveloped by Deepak Unni, Justin Reese, J. Harry Caufield, and Harshad Hegde.
Package: neatnearestneighbour
A Nearest Neighbour algorithm written in pure python. The intention is
to use this package with PyPy. The hot loop in the algorithm are perfect for PyPy's
just-in-time compilation and results in fast performance.To run create an instance of NearestNeighbour and call run(). The output is a
generator of items in order by finding the next nearest neighbour of each item. The
starting item is randomized.The input items can be a list of anything, because the distance function also
has to be provided. The distance function must be able to calculate the distance
between any items in the input list.An example:fromneatnearestneighbourimportNearestNeighbouritems=[10,20,15,5,100,2,30,50]distance_fn=lambdaa,b:abs(b-a)nn=NearestNeighbour(items,distance_fn,)neighbours=nn.run()print(list(neighbours))# [50, 30, 20, 15, 10, 5, 2, 100]
Package: neato-coding-challenge-tcp-client
FeaturesTODORequirementsTODOInstallationYou can installNeato Coding Challenge - TCP ClientviapipfromPyPI:$pipinstallneato-coding-challenge-tcp-clientUsageTODOContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMITlicense,Neato Coding Challenge - TCP Clientis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz’sHypermodern Python Cookiecuttertemplate.
Package: neato-coding-challenge-tcp-server
FeaturesTODORequirementsTODOInstallationYou can installNeato Coding Challenge - TCP ServerviapipfromPyPI:$pipinstallneato-coding-challenge-tcp-serverUsageTODOContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMITlicense,Neato Coding Challenge - TCP Serveris free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz’sHypermodern Python Cookiecuttertemplate.
Package: neatpy
neatpyneatpy is a library that implements the NEAT algorithm designed by Kenneth O. Stanley which is documented in thispaper. This method evolves neural network topologies along with weights on the foundation of a genetic algorithm.Why neatpy?Some reasons to use neatpy:Easy to useCode is easier to understandCan be translated to other languages without much difficultyLittle to no knowledge of configuration is required to get startedInstallationpip install neatpyBasic XOR examplefromneatpy.optionsimportOptions# import options class for configurationfromneatpy.populationimportPopulation# import population class# XOR inputs and outputsxor_inp=[(0,0),(0,1),(1,0),(1,1)]xor_out=[0,1,1,0]# evaluate functiondefevaluate(brains):fornninbrains:nn.fitness=4forxi,xoinzip(xor_inp,xor_out):output=nn.predict(xi)[0]nn.fitness-=(output-xo)**2# number of inputs - number of outputs - population size - maximum fitness neededOptions.set_options(2,1,150,3.9)p=Population()best,solved=p.evaluate(evaluate,400)# evaluating population for 400 generations or till maximum fitness is reached# testing the best neural networkevaluate([best])print(best.fitness)NotesFor every environment anevaluatefunction needs to be created that takes every generation's populationTo customize the algorithm even further, optional arguments inOptions.set_optionscan be tweakedWhen the evaluation ends the method returns the best brain and whether the environment was solved (maximum fitness reached) or notXOR Loose exampleImitating the evaluate method in Population() we can write the above code as:fromneatpy.optionsimportOptionsfromneatpy.populationimportPopulationOptions.set_options(2,1,150)p=Population()xor_inp=[(0,0),(0,1),(1,0),(1,1)]xor_out=[0,1,1,0]max_fitness=3.9# maximum fitness# while the maximum fitness hasn't been reachedwhilep.best.fitness<max_fitness:fornninp.pool:nn.fitness=4forxi,xoinzip(xor_inp,xor_out):output=nn.predict(xi)[0]nn.fitness-=(output-xo)**2p.epoch()# create a new poolprint(p)# __str__ method gives the statisticsbest=p.best# best brain
Package: neatutils
neatutilsA Simple Reference Utility for Getting the Abbreviation of ML Estimators,Algorithms and Awesome ListInstallationpipinstallneatutilsBenefitsSimplify finding ML estimator name for pycaretWhy Neatutils?During usage of the powerful ML library Pycaret, I noticed that it was difficult to know which abbreviation/short name can be used each ML Estimator, hence we decided to build something simple to make it easier to know the most common name/abbreviation for most Machine Learning/Data Science Algorithms and Estimators used.UsageGet AbbreviationsNeatutils offers the ability to analyse sequences for more insight>>>importneatutils>>>neatutils.get_abbrev('Logistic Regression')>>>lrGet Full Name of Estimators>>>importneatutils>>>neatutils.get_fullname('lr')'Logistic Regression'DocumentationPlease read thedocumentationfor more information on what neatutils does and how to use is for your needs.More Features To Addawesome listsupport for more file formatsAcknowledgementsInspired by packages like PyCaret,Awesome-hubNBContributions Are WelcomedNotice a bug, please let us know.Thanks A lotByJesse E.Agbe(JCharis)Jesus Saves @JCharisTech
Package: nebari-plugin-label-studio-chart
Nebari Plugin Label-Studio ChartOverviewThis plugin integrates Label Studio into the Nebari platform, allowing seamless labeling functionality within Nebari. Utilizing Python, Terraform, Kubernetes, and Helm charts, the plugin provides a configurable deployment and authentication through Keycloak.Design and ArchitectureThe plugin follows a modular design, leveraging Terraform to define the deployment of Label Studio within a Kubernetes cluster. Key components include:Terraform Configuration: Defines variables, outputs, and resources for deployment, including Helm release, Keycloak authentication, and Kubernetes secrets.Helm Chart Integration: Deploys Label Studio as a Helm chart within the specified Kubernetes namespace.Authentication: Utilizes Keycloak for OpenID authentication, including user roles and group memberships.Installation Instructionspip install nebari-plugin-label-studio-chartUsage InstructionsConfigurations: Various configurations are available, including domain, realm ID, client ID, signing key, and namespace settings.Authentication: Enable or disable authentication and define specific OpenID parameters.Configuration DetailsPublicConfiguration of the Label Studio plugin is controlled through thelabel_studiosection of thenebari-config.yamlfor the environment.label_studio:# helm release name - default label-studioname:label-studio# target namespace - default (nebari global namespace)namespace:label-studio# enable or disable traefik auth proxy and keycloak integrationauth:enabled:true# helm chart values overridesvalues:{}InternalThe following configuration values apply to the internally managed terraform module and are indirectly controlled through related values innebari-config.yaml.name: Chart name for Helm release.domain: Domain for the plugin's deployment.realm_id,client_id: Keycloak authentication settings.base_url,external_url,valid_redirect_uris: OpenID URLs.signing_key_ref: Signing key reference information.create_namespace,namespace: Kubernetes namespace configuration.overrides: Map for overriding default configurations.auth_enabled: Flag to enable/disable authentication.Testing OverviewThe plugin includes unit tests to validate its core functionalities:Constructor Test: Verifies the default name and priority.Input Variables Test: Validates domain, realm ID, client ID, and external URL settings.Default Namespace Test: Tests the default namespace configuration.Version InformationPlugin Version: 0.0.5Licensenebari-plugin-label-studio-chartis distributed under the terms of theApachelicense.