Saravanan666/pypi-org huggingface dataset:
Package: nodify-plugin
Nodify Tensorboard PluginThis is a tensorboard plugin byTrainyto supplement the existingPyTorch Profiler. This provides additional visualizations to effectively characterize traces for runs involving multiple GPUs. The plugin expects all traces to be collected usingtorch.profileand to be located in the same folder.Installation & QuickstartInstall tensorboard and the plugin.pip install tensorboard
pip install nodify-pluginGenerate PyTorch profiler traces as shownhereand bring up the tensorboard where your traces are living. A set of example logs are provided in this repo underlog/resnet18tensorboard --logdir log/resnet18/DevelopmentTo view the plugin for development, create a virtual environment, install the requirements, and install the plugin.python -m venv venv
. venv/bin/activate
pip install -e .Feature roadmapA lot of the features on the roadmap use Meta'sDynolog,kineto, andholistic trace analyzer.On-demand tracing and metrics through dynologgerRecommendations for fixing multinode bottlenecksreading from logs stored on cloud object-stores (e.g. Amazon S3, Azure Blob)ContributingFor feature requests or bug reports/fixes, feel free to open a Github issue or make a pull request. We'd love to connect with any interested developers and we check ourDiscordto discuss the direction of our projects everyday. Connect with us either throught the text channels or through DM's.
Package: nodimo
NodimoThe main purpose of Nodimo is to transform a dimensional relationship between variables into a nondimensional one. The variables are gathered in nondimensional groups such that the number of groups is lower than the number of variables. The resulting nondimensional model is, at the same time, a generalization and simplification of the dimensional model.Nodimo supports any number of dimensions and variables. It can be used for applications in science, engineering, economics and finance. The resulting nondimensional groups can be used as the basis for further studies in similarity and model testing.InstallationNodimo and its dependencies (numpyandsympy) are installed by:pipinstallnodimoWhen running Nodimo on the terminal, make sure that the terminal supports Unicode characters. For the best experience, it is recommended the use ofjupyter notebook.Getting startedBasic exampleSimple pendulum:The nondimensional model for the pendulum's period as a function of the other variables is built and displayed as:fromnodimoimportVariable,NonDimensionalModel# Variables' dimensions: Mass (M), Length (L) and Time (T)T=Variable('T',M=0,L=0,T=1,dependent=True)# periodL=Variable('L',M=0,L=1,T=0,scaling=True)# lengthm=Variable('m',M=1,L=0,T=0)# massg=Variable('g',M=0,L=1,T=-2,scaling=True)# gravityt0=Variable('theta_0')# initial anglendmodel=NonDimensionalModel(T,L,m,g,t0)ndmodel.show()And the result is:\displaystyle \frac{T g^{\frac{1}{2}}}{L^{\frac{1}{2}}} = \Pi{\left(\theta_{0} \right)}For more functionalities and examples, check the documentation.LicenseNodimo is open-source and released under theMIT License
Package: nod-labs-NNS
NodLabsNNS pip packageNod Labs AutoML package for neural architecture search and model training of image classificationRequirementsAccess to Cloud TPUs (Official Cloud TPU Tutorial)Tensorflow 1.15Python 3.5+Specific stepsinstall pip packagepip3 install nod-labs-NNS==0.0.1Setting up ImageNet datasetTo setup the ImageNet follow the instructions fromhereUse nodlabsNNS package for neural architecture search and traincreate a python fileSearchimport nns

model = model.nod_detection('tpu','your-tpu-name','your-bucket-name')
model.dataset('imagenet')
model.search_model()Trainimport nns

model = model.nod_detection('tpu','your-tpu-name','your-bucket-name')
model.dataset('imagenet')
model.train_model()Currently nns only support TPU for searching and training and only support IMAGENET dataset.
Package: no-dm-discord
No-DM Discord BotIntroductionThis Python package is designed for interacting with the Discord API to enable or disable direct messaging (DM) on a Discord server. It utilizes environment variables for secure and flexible configuration.InstallationTo install and use this package, follow these steps:Clone the repository:gitclone[your-repository-url]Navigate to the cloned directory:cdno-dm-discordInstall required dependencies:pipinstall-rrequirements.txtConfigurationBefore running the script, you need to set up the following environment variables in a.envfile:DISCORD_BOT_TOKEN: Your Discord bot token.DISCORD_GUILD_ID: The Guild ID of your Discord server.Example.envfile:DISCORD_BOT_TOKEN=your_bot_token
DISCORD_GUILD_ID=your_guild_idUsageRun the script using Python:pythonmain.pyGetting a Bot TokenTo obtain a bot token:Visit theDiscord Developer Portal.Create a new application and add a bot to it.Copy the bot token provided.Setting Up the BotEnsure your bot has administrative permissions on the Discord server for it to function correctly.Getting the Guild IDTo find your Discord server's Guild ID:Enable Developer Mode in Discord (Settings -> Advanced -> Developer Mode).Right-click your server name and click 'Copy ID'.ContributingContributions to this package are welcome. Please follow these steps to contribute:Fork the repository.Create a new branch for your feature.Commit your changes.Push to the branch.Open a pull request.Code SampleBelow is a simple example of how to use this package within your Python project to disable DMs for your Discord server:fromno_dm_discordimportupdate_discord_status# Ensure your .env file has the DISCORD_BOT_TOKEN and DISCORD_GUILD_ID setupdate_discord_status()print("DMs have been successfully disabled.")This example assumes you have set up your environment variables correctly and have theno_dm_discordpackage installed in your environment.Remember, the actual function call and package import might need to be adjusted based on your package structure and function definitions.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: nodule
NoduleConvert, visualize and iterate over heterogeneous trees.UsageUsage: nodule [OPTIONS] FORMAT PATH

  Convert file at PATH to FORMAT. Supported formats are: JSON, TOML, YAML.
  MERMAID is also supported as an output format.

  Use `import nodule.nod` to build your own conversion, visualization or
  iteration tool.

Options:
  --help  Show this message and exit.Out of scopeRound trips (X -> X, X -> Y -> X) do not preserve whitespace, comments and
layout choices.The built-in Mermaid visualizer may fail with duplicate node names,
non-alphanumeric characters and other non-trivial data. Use thenodifyiterator method to build a robust solution for your use-case. Similarly for
smarter and more compact visualizations.Development environmentInstall prerequisitesPython 3.10pdmmakepipx (optional, required formake install-source)InstructionsFork the upstream repository.git clone [fork-url]cd [project-folder]Runmake developto initialise your development environment.You can use any text editor or IDE that supports virtualenv / pdm. See the
Makefile for toolchain details.Pleasemake testandmake lintbefore submitting changes.Make targetsUSAGE: make [target]

help    : Show this message.
develop : Set up Python development environment.
run     : Run from source.
clean   : Remove all build artefacts.
test    : Run tests and generate coverage report.
lint    : Fix or warn about linting errors.
build   : Clean, test, lint, then generate new build artefacts.
publish : Upload build artefacts to PyPI.
install-source : Install source as a local Python application.Sharing and contributionsNodule
https://lofidevops.neocities.org
Copyright 2023 David Seaward and contributors
SPDX-License-Identifier: Apache-2.0Shared under Apache-2.0. We adhere to the Contributor Covenant 2.1, and certify
origin per DCO 1.1 with a signed-off-by line. Contributions under the same
terms are welcome.Submit security and conduct issues as private tickets. Sign commits withgit commit --signoff. For a software bill of materials runreuse spdx. For
more details see CONDUCT, COPYING and CONTRIBUTING.
Package: noeku.linguacollage
Helps to translate Collage pages with LinguaPlone.FeaturesTranslates Collage recursivly with all contents on translation.Translates parts of a Collage recursivlyNew rows, columns, aliases and contents are created in all prior translated languages.Deleted rows, columns, aliases and content is removed in all translations.All translated items are in initial state (private by default) and empty.On edit of an untranslated item the split view appears.Source Code and ContributionsIf you want to help with the development (improvement, update, bug-fixing, …) ofnoeku.linguacollagethis is a great idea!The code is located in thegithub bluedynamics repository.You can fork it and work on the project.
We are waiting for your pull requests.Maintainer of noeku.linguacollage is Jens Klein.
We appreciate any contribution and if a release is needed to be done on pypi:
please just contact one of usBlueDynamics Developers.LicenseThe project is licensed under the GPLv2.ContributorsJens W. Klein <jens@bluedynamics.com> - AuthorThis project was initiated and paid byNiederösterreich Kulturwirtschaft GmbHChangelog1.0a1 (2015-12-21)Initial release.
[jensens]
Package: noeq
python-noeqpython client library for noeqdlinksSeehttps://github.com/noeq/noeqdlicenseCopyright (C) 2012 Chris PetersenPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: noerr
noerrCatch exceptions via context manager in Python.Super simple to use:fromnoerrimportno_errwithno_err:raiseException("This won't crash my code!")print("Yup, still going with no error!")Also possible to log errors:fromnoerrimportlog_errwithlog_err:raiseException("Should probably warn the user about this one.")print("We now see the error, but don't stop because of it")Outputs:Exception logged by "LogError"
Traceback (most recent call last):
  File "<input>", line 4, in <module>
Exception: Should probably warn the user about this one.

We now see the error, but don't stop because of itInstallpip install noerrLicenseMIT License - Copyright (c) 2020 Chris Griffith - See LICENSE
Package: noesis
Official Python API forNOESIS, an open source framework for network data mining that provides a large collection of network analysis techniques, including the analysis of network structural properties, community detection methods, link scoring, and link prediction, as well as network visualization algorithms.InstallationFromPyPi:pip install noesisFrom source:git clone https://github.com/fvictor/noesis-python.git
cd noesis-python
python setup.py installGetting startedNOESIS for Python provides simple and unified interfaces for most of the implemented techniques. The following example loads a network from a GML file and detects its communities using the Kernighanâ€“Lin algorithm:fromnoesisimportNoesisns=Noesis()network_reader=ns.create_network_reader('GML')network=network_reader.read('my_network.gml')community_detector=ns.create_community_detector('KernighanLin')communities=community_detector.compute(network)fornodeinrange(network.nodes()):print('Node{}belongs to community{}'.format(node,communities[node]))ns.end()The following example generates a network of 20 nodes and 100 links using the ErdÃ¶sâ€“RÃ©nyi model and computes the PageRank score of each node:fromnoesisimportNoesisns=Noesis()network=ns.create_network_from_model('ErdosRenyi',20,100)pagerank_scorer=ns.create_node_scorer('PageRank',0.9)scores=pagerank_scorer.compute(network)fornodeinrange(network.nodes()):print('Node{}has a PageRank score of{}'.format(node,scores[node]))ns.end()Always remember to call theendmethod ofNoesisclass to properly terminate the NOESIS session and finish the execution of your program.DocumentationThe documentation of the project, which can be built usingSPHINX, is located in thedocfolder. A readily available up-to-date version of the documentation can be found athttp://noesis-python.readthedocs.io.
Package: noether
Noether523 units, 60 prefixesNoetheris a unit-enriched Python package, akin to Wolfram Alpha or gnuunits. It has a large (and expanding) catalogue of up-to-date units and constants, allowing code to be written directly in the units they are concerned with while also ensuring e.g. you don't mistakenly add an energy to a length.Just grab Python 3.10 or later andpip install noetherto run!Development is ongoing, especially in expanding the unit catalogue and improving unit display mechanisms.UsageNoether can be used as a Python package or as a CLI:$aliasnoe='python -im noether'$noemarathon
marathon# length, 42195 m, Race length based on Greek legend, set by convention from 1908 Summer Olympics$noether23degC@degF73.4°F# temperature$noether'horsepower @ dB(kW)'-1.33418061dB(kW)# power, 0.73549875 kWThe CLI allows a few niceties such as slightly terser syntax, but otherwise behaves identically to Python:$noether5cm@in--value1.9685039370078738
$python
>>>fromnoetherimport*
>>>5*cm@inch1.9685039370078738in# lengthIn addition to@for display, you can more permanently set display units:>>>display(inch)>>>5*cm>>>milemile# length, 63360 inUnits propagate uncertainty automatically under most operations:>>>m(5,0.1)**3125±7.5m**3# volumeYou can define your own units and dimensions:>>>foo=Unit(3e11*furlong/fortnight,'foo')>>>c@foo6.008724999284181foo# speed>>>health=Dimension.new('health','H')>>>apple=Unit(health,'apple','a')>>>apple/dayapple/day# health / time, 1.1574074074074073e-05 a / sVariousconfsettings allow for customisation to behaviour:>>>conf.info_spectrum=True>>>nm(400)4e-07m# length, visible, purpleUseconf.save()to save to (by default)~/.config/noether.toml.For more, see...CHANGELOG.mdCONTRIBUTING.mdLICENSE.txtOther tools for working with units include:Wolfram Alpha, a comprehensive online intelligence enginegnuunits, a command-line tool you likely already haveunits, a simple Python package for defining your own unitsunyt, a Python package with numpy support📚Did you know?>>> lunation / (year % lunation)
2.7153489666011486Alunation(about 29 days) separates one full moon from another. Every so often a thirteenth full moon occurs in a year - "ablue moon". "Once in a blue moon" is actually only every 2.71 years or so - not as rare as you'd think. Don't tell Sinatra!
Package: noether-api
How to installpip install noether-apiHow to useLet's ask Noether about the following image:# Import NoetherClient
from noether_api import NoetherClient

# Create Noether client
noether = NoetherClient(api_key="...")

image_url = "https://cdn.vox-cdn.com/thumbor/oCiqoTZlurIloHrG8O3cHqpBOiE=/241x193:2304x1644/1200x800/filters:focal(1034x301:1446x713)/cdn.vox-cdn.com/uploads/chorus_image/image/53741489/618916710.0.jpg"

# Ask 
result = noether.ask(
	image_url=image_url,
	question="What color are the letters on the player's shirt?"
)
print(result)The script above should print the following:{'data': ['white'], 'success': True}Let's ask a few more questions:result = noether.ask(
	image_url=image_url,
	question="What color is the player's shirt?"
)
print(result){'data': ['black'], 'success': True}result = noether.ask(
	image_url=image_url,
	question="What sport are they playing?"
)
print(result){'data': ['basketball'], 'success': True}Visitnoether.devfor more details.
Package: noformat
Basically, noformat treats a folder structure as a single dict that
contains data and attributes. Pandas dataframe and numpy array can be
used for dict values.importnumpyasnpimportpandasaspdfromnoformatimportFiledata=File('data/temp','w-')data['first_array']=np.random.randn(10,10)data['second_array']=pd.DataFrame(data=np.random.randn(10,4),columns=['1','2','3','4'])Files will be automatically saved upon object destruction. And loaded
laterread_data=File('data/temp','w+')assert(read_data['first_array'].shape==(10,10))Attributes will be saved in ‘attributes.json’ filesread_data=File('data/temp','w+')read_data.attrs['first_attribute']=64This will create a folder with the following structuredata/temp/
|   first_array.npy
|   second_array.msg
└───attributes.jsonLogging files for the data can be included: 1. in json format with .log
extension 2. in cell array format with .mat extension It can only be
written in the first type
Package: nofus
NOFUS: Nate's One-File Utilities StashAbout NOFUSA collection of single purpose classes for common tasks, focusing on simple and
straightforward use. Each class can be taken and used individually and requires
no external dependencies.UsesConfigFile: No Hassle Config File ParserLogger: Simplified Alternate Logging InterfaceConfigFile: No Hassle Config File ParserExample Config:[email]
admin    = admin@example.com
reply_to = feedback@example.com

[auth.sql]
host = sql.example.com
db   = mydbname
user = sqluser
pw   = "secret_passwd"

[auth.ldap]
uri = "ldap://ldap1.example.com:389"
uri = "ldap://ldap2.example.com:389"
uri = "ldap://ldap3.example.com:389"Example Use:from nofus import ConfigFile

conf = ConfigFile("/path/to/my.conf")
if not conf.load():
    print(conf.errors())
else:
    admin_email = conf.get("email.admin")
    reply_email = conf.get("email.reply_to", default="donotreply@example.com")

    sqlauth     = conf.get("auth.sql")
    sql_host    = sqlauth.get("host")
    sql_db      = sqlauth.get("db")
    sql_user    = sqlauth.get("user")
    sql_pw      = sqlauth.get("pw")

    ldap_uris   = conf.get_list("auth.ldap.uri")Logger: Simplified Alternate Logging InterfaceExample Use:from nofus import Logger

# Fast setup, default to logging LOG_DEBUG and higher
Logger.initialize('/tmp/myfile.log')
Logger.info("Info!")
Logger.notice("Notice!")
Logger.warning("Warning!")
Logger.error("Error!")
Logger.critical("Critical!")

# Easily put an exception stack trace into the log
try:
    1/0
except ZeroDivisionError as exc:
    Logger.info("Caught something.", exc_info=exc)

# Disable logging
Logger.disable()

# Set custom log level
Logger.initialize('/tmp/myfile.log', Logger.LOG_TRACE)
Logger.trace("Trace!")

# Check log level
if Logger.is_enabled(Logger.LOG_DEBUG):
    Logger.debug("Yep, we're debugging.")

# Or Define a custom logger
from nofus import LoggingInterface
class CustomLogger(LoggingInterface):
    def __init__(self, log_file=None, log_level=None):
        if log_level is None:
            log_level = Logger.LOG_LOW
        # Customize your init

    def make_log(self, entry, log_level):
        # Customize your log actions

Logger.register(CustomLogger())InstallationIf all you need is one class, you can just grab a file and throw it in your project.Or you can install the whole stack usingpip:pip install nofusLicenseNOFUS is covered by the Simplified BSD License.
Package: nogan-synthesizer
NOGAN SYNTHESIZERNoGANSynthesizer is a library which generates synthetic tabular data based on methods of multivariate binning. It offers faster, more accurate and less complex alternative to GAN.ClassNoGANSynthesizer: Synthetic Data Generator that fits a tabular dataFunctionswrap_category_columns: Function to compress all specified categorical columns into oneunwrap_category_columns: Function to expand all wrapped categorical columnsAuthorsDr. Vincent Granville- ResearchRajiv Iyer- Development/MaintenanceInstallationThe package can be installed withpip install nogan_synthesizerTestsThe test can be run by cloning the repo and running:pytest testsIn case of any issues running the tests, please run them after installing the package locally:pip install -e .UsageStart by importing the classfromnogan_synthesizerimportNoGANSynthfromnogan_synthesizer.preprocessingimportwrap_category_columns,unwrap_category_columnsfromgenai_evaluationimportmultivariate_ecdf,ks_statisticAssuming we have a pandas dataframe (Real) having some categorical columns and we are interested in generating Synthetic based on that.
We first prepocess the categorical columns which will return preprocessed real dataset & its corresponding flag vector index to key value dictionarycat_cols=[categorycolumnslist...]wrapped_real_data,idx_to_key,key_to_idx=\wrap_category_columns(real_data,cat_cols)We then fit the NoGANSynth Model on the wrapped dataset and generate synthetic datanogan=NoGANSynth(real_data)nogan.fit()n_synth_rows=len(real_data)synth_data=nogan.generate_synthetic_data(no_of_rows=n_synth_rows)We can then evaluate the synthetic & real data distributions using genai_evaluation package_,ecdf_val1,ecdf_synth=\multivariate_ecdf(wrapped_real_data,synth_data,n_nodes=1000,verbose=True,random_seed=42)ks_stat=ks_statistic(ecdf_val1,ecdf_synth)Once we are satisfied with the evaluation results, we can unwrap the Generated Synthetic dataset (unwrap the categorical columns) using the previously generated flag vector index to key dictionaryunwrapped_synth_data=unwrap_category_columns(synth_data,idx_to_key,cat_cols)MotivationThe motivation for this package comes from Dr. Vincent Granville's paperGenerative AI Technology Break-through: Spectacular Performance of New SynthesizerIf you have any tips or suggestions, please contact us on email.History0.1.0 (2023-09-19)First release on PyPI.0.1.1 (2023-09-27)FixedResolved issues with single categorical columns0.1.2 (2023-09-27)FeatureAdded Feature for flexible Uniform & Gaussian Sampling for columns in generate_synthetic_data method0.1.3 (2023-10-10)FixedResolved issues with float column when selected as category column0.1.4 (2023-10-16)FixedResolved issues with brackets "(" & ")" in category column values0.1.5 (2023-10-24)FeatureAdded gen random seed to be set during generation
Package: noggin
noggin is a simple tool for logging and plotting measurements during an experiment. In particular, it
was created as a convenient means for recording metrics while training a neural network, thus it is
designed around the familiar training/testing and batch/epoch paradigms.noggin is able to perform “live plotting” and automatically update its plots throughout an experiment.
Its logging interface also makes it easy to save and load recorded metrics, and seamlessly resume your experiment.
These metrics can also be accessed as an N-dimension array with labeled axes, by making keen use of thexarraylibrary.