Saravanan666/pypi-org huggingface dataset:
Package: tftui
TFTUI - The Terraform textual UITFTUIis a powerful textual UI that empowers users to effortlessly view and interact with their Terraform state.With its latest version you can easily visualize the complete state tree, gaining deeper insights into your infrastructure's current configuration. Additionally, the ability to search the tree and inspect individual resource states allows you to focus on specific details for better analysis and management. It's also possible to select specific resources and perform actions such as tainting, untainting and deleting them. Finally, you are now able to create and apply plans directly from the UI.Key FeaturesComprehensive display of the entire Terraform state treeEffortlessly view and navigate through a single resource stateSearch the state tree and resource definitionsCreate plans, present them in full colors and apply them directly from the TUISingle/multiple resource selectionOperate on resources: taint, untaint, delete, destroySupport for Terraform wrappers (e.g. terragrunt)Changelog (latest versions)Version 0.12Enabled targeting specific resources for plan creationIntroducing cli argument: tfvars fileAdded destroy functionalityAdded a help screenAdded dynamic value for "targets" checkbox (checkbox is marked when resources are selected)Added a short summary of the suggested plan before applying itAdded a redacted error tracker on unhandeled exceptions (only when usage reporting is enabled)Fixed: search through full module namesVersion 0.11Added support for creating plans (in vivid colors!) and applying themChanged the confirmation dialog to a modal screenAdded coloring to tainted resources considering some terminals can't display strikethrough correctlyImproved loading screen mechanismVersion 0.10Perform actions on a single highlighted resource without pre-selecting itUser interface overhaul: added logo, fixed coloring and loading indicatorAdded resource selection via the space key and tree traversal via the arrow keysAdded a lightmode command-line argumentAdded a debug log command-line argumentCopy to clipboard now copies the resource name in the tree viewFixed a bug in the remove resource functionalityFixed a bug in the parsing mechanism (colons, dots)Refactor: globalsDemoInstallationToolInstallUpgradeRunHomebrewbrew install idoavrah/homebrew/tftuibrew upgrade tftuicd /path/to/terraform/project && tftuiPIPpip install tftuipip install --upgrade tftuicd /path/to/terraform/project && tftuiPIPXpipx install tftuipipx upgrade tftuicd /path/to/terraform/project && tftuiUsage TrackingTFTUI utilizesPostHogto track usage of the application.This is done to help us understand how the tool is being used and to improve it.No personal data is being sent to the tracking service. Returning users are being uniquely identified by a generated fingerprint.You can opt-out of usage tracking completely by setting the-dflag when running the tool.Star History
Package: tfunct
Welcome to Temperature Response FunctionsThis is a small package for estimating wheat yield. it estimates yield under non-stressed and VPD stressed conditions as a function of temperature.Authors:Azam Lashkari (azam.lashkari@jic.ac.uk)Urs Christoph Schulthess (U.Schulthess@cgiar.org)Ernesto Giron E. - (e.giron.e@gmail.com)Reference:Azam et al. Searching for optimal temperature response function for grain filling period to simulate wheat yield across the globe. In Press.Quick startThe package for temperature response functions can be installed withpip:pipinstalltfunctFor detailed installation instructions, configuration options, and a demo, visitinstallationLicenseMIT LicenseCopyright (c) 2021-2023Permission 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 NON-INFRINGEMENT. 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.Copyright (c) 2023 CIMMYT-Henan Collaborative Innovation Center
Package: tfunicode
tfunicodeCustom ops for TensorFlow to deal with unicode strings:expand_split_wordsexpand_split_charsexpand_char_ngramstransform_normalize_unicodetransform_title_casetransform_lower_casetransform_string_replacetransform_regex_replacetransform_upper_casetransform_zero_digitstransform_wrap_withSeetfunicode/python/kernel_testsdirectory for usage examples.InstallationInstall package as usual:pip install -U tfunicode
Package: tf-utilities
tfuA small library of many useful utilities for Tensorflow training workflows.Filtering Visible DevicesIn some instances, you may want to filter what devices are visible to Tensorflow. For example, you may have multiple GPUS, but would prefer to use only a single GPU instance when training your model.tf_utilsincludes some convenience methods to assist with this.Selecting a single GPU:visible_devices=tfu.devices.select_gpu(0)Selecting a subset of GPUs:visible_devices=tfu.devices.select_gpu([0,1])Training StrategiesWhen a training strategy is needed, in particularOneDeviceStrategyorMirroredDeviceStrategy,tf_utilsprovides some convenience functions to create these strategies automatically and filter out unused devices. Some examples are provided below.Use the CPU only via a OneDeviceStrategy:strategy=tfu.strategy.cpu(0)Use a single GPU via the OneDeviceStrategy:strategy=tfu.strategy.gpu(0)Use multiple GPUs via the MirroredDeviceStrategy:strategy=tfu.strategy.gpu([0,1])Dynamic Memory GrowthTensorflow has the ability to use dynamic memory allocation, rather than allocating all of the memory on the GPU at once. Enabling dynamic memory allocation allows you to not only monitor memory usage of your models during training, but it also grants you the ability to run multiple models on a single GPU instance. All device selection and strategy functions withintf_utilssupport this feature via theuse_dynamic_memoryflag.Enabling dynamic memory growth via device selection:visible_devices=tfu.devices.select_gpu(0,use_dynamic_memory=True)Enabling dynamic memory growth via strategy creation:strategy=tfu.strategy.gpu(0,use_dynamic_memory=True)
Package: tfv
TFVThe tfv package is a suite of tools for post-processing results from theTUFLOW FVhydrodynamic, sediment transport, water quality and particle tracking modelling software.It is also provides a basic framework for extracting and visualizing 2D and 3D oceanographic and atmospheric model result data on unstructured meshes.InstallingThe tfv package is available via the Python Package Index (PyPi) orConda Forge.Note: Version 1.0.7 has been built and tested on Python 3.9 to 3.11.To install tfv from the conda command line tool:conda install -c conda-forge tfvAlternatively to install tfv using pip:python -m pip install tfvDependenciesThe tfv package depends on the following core packages:matplotlib >= 3.2.2
netCDF4 >= 1.5.3
numpy >= 1.19.0
xarray>=v2022.03.0
dask>=2022.01.0
scipy>=1.6.0
tqdm>=4.50.0These will be automatically installed or updated as part of the tfv installation.The following packages provide additional functionality and arenotinstalled by default:ipywidgets >= 8.0.0- Required for interactive results vizulisation in an interactive session (e.g., JuypterLab)PyQt5 >= 5.15.0- Required for interactive popout results vizulisationTutorials, Documentation & SupportSee theAPI Referencefor code documentation andTUFLOW FV Python Toolsfor tutorials and demonstration
datasets.For support contactTUFLOW Support.LicenseThis project is licensed under the MIT License - see theLICENSE.txtfile for details
Package: tfvan
tfvanKeras (TensorFlow v2) reimplementation ofVisual Attention Networkmodel.
Based onOfficial Pytorch implementation.Supports variable-shape inference. All weights are obtained by converting official checkpoints.InstallationpipinstalltfvanExamplesDefault usage (without preprocessing):fromtfvanimportVanTiny# + 3 other variants and input preprocessingmodel=VanTiny()# by default will download imagenet-pretrained weightsmodel.compile(...)model.fit(...)Custom classification (with preprocessing):fromkerasimportlayers,modelsfromtfvanimportVanTiny,preprocess_inputinputs=layers.Input(shape=(224,224,3),dtype='uint8')outputs=layers.Lambda(preprocess_input)(inputs)outputs=VanTiny(include_top=False)(outputs)outputs=layers.Dense(100,activation='softmax')(outputs)model=models.Model(inputs=inputs,outputs=outputs)model.compile(...)model.fit(...)EvaluationFor correctness,TinyandSmallmodels (original and ported) tested
withImageNet-v2 test set.importtensorflowastfimporttensorflow_datasetsastfdsfromtfvanimportVanTiny,preprocess_inputdef_prepare(example):# Observation: +2.2% top1 accuracy in tiny model with antialias=Trueimage=tf.image.resize(example['image'],(248,248),method=tf.image.ResizeMethod.BICUBIC)image=tf.image.central_crop(image,0.9)image=preprocess_input(image)returnimage,example['label']imagenet2=tfds.load('imagenet_v2',split='test',shuffle_files=True)imagenet2=imagenet2.map(_prepare,num_parallel_calls=tf.data.AUTOTUNE)imagenet2=imagenet2.batch(8)model=VanTiny()model.compile('sgd','sparse_categorical_crossentropy',['accuracy','sparse_top_k_categorical_accuracy'])history=model.evaluate(imagenet2)print(history)nameoriginal acc@1ported acc@1original acc@5ported acc@5Tiny59.2261.5982.3284.52Small70.1768.6289.1788.54Citation@article{guo2022visual,
  title={Visual Attention Network},
  author={Guo, Meng-Hao and Lu, Cheng-Ze and Liu, Zheng-Ning and Cheng, Ming-Ming and Hu, Shi-Min},
  journal={arXiv preprint arXiv:2202.09741},
  year={2022}
}
Package: tfvardoc
# tf-vardoc## Important NoteThis is a _work-in-progress_!  It still needs to be "productionalized" by making it into a proper commandline utility.## What is this?This is a utility for generating documentation regarding [Terraform](https://github.com/hashicorp/terraform)variables.## Why is that important?1. The only thing worse than _no documentation_ is _stale/incorrect documentation_.2. A part of defining Terraform variables is self-documentatin; you set variable types, descriptions, and defaults as code.3. While you could just _read the code_, it's good practice to include a `README.md` for any Terraform module.4. This is now a problem if you like to make purdy, stylized `README`s; there's no easy/quick way to transform yourvariable definitions to documentation.*Until now...*## How do I use it?Create a `README.md.j2` [jinja2 template](http://jinja.pocoo.org/docs/2.9/). Your variables will be available underthe `variables` variable.  Stylize to your hearts content.## TODO- make this a proper commandline tool with args and configuration- setup pip package- distribute
Package: tf-vars-to-pydantic
FeaturesRead a Terraform Variables HCL file (variables.tf) and create a Pydantic model from itInterpret complex data types (list(string), etc) into Python data typesInterpret object data types into sub modelsDoes not currently support terraform input validationRequirementsPython ^3.11Pydantic ^1.10.xpython-hcl2 ^4.3.xInstallationYou can installTf Vars To Pydanticvia [pip] from [PyPI]:pip install tf-vars-to-pydanticUsageAssuming you have a tf vars file that looks like:variable "foo" {
  description = "String variable"
  type        = string
}

variable "bar" {
  description = "String variable with default"
  type        = number
}

variable "baz" {
  type        = list(string)
}

variable "qux" {
  description = "Boolean variable"
  default     = true
  type        = bool
}fromtf_vars_to_pydanticimportconvert_fileTFVarsModel=convert_file(path="./tests/fixtures/simple.tf",model_name="TFVarsModel")tfvars_as_pydantic=TFVarsModel(foo="test",bar=7.2,baz=['boop','bing','bong'])print(tfvars_as_pydantic)# foo='test' bar=7.2 baz=['boop', 'bing', 'bong'] qux=TrueContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,Tf Vars To Pydanticis free and open source software.IssuesIf you encounter any problems,
please [file an issue] along with a detailed description.ContributorsAndrew💻⚠️📖
Package: tfvit
tfvitKeras (TensorFlow v2) reimplementation ofVision Transformermodel.Based onOfficial implementation.Contains pretrained weights converted from official ones.Contains pretrained weights converted fromDinoV2+Registers.InstallationpipinstalltfvitExamplesDefault usage (without preprocessing):fromtfvitimportViTBase32384# + 11 other variants and input preprocessingmodel=ViTBase32384()# by default will download imagenet[21k]-pretrained weightsmodel.compile(...)model.fit(...)Custom classification (with preprocessing):fromkerasimportlayers,modelsfromtfvitimportViTBase32224inputs=layers.Input(shape=(224,224,3),dtype='uint8')outputs=ViTBase32224(include_top=False)(inputs)outputs=layers.Dense(100,activation='softmax')(outputs)model=models.Model(inputs=inputs,outputs=outputs)model.compile(...)model.fit(...)DifferencesCode simplification:Pretrain input height and width are always equalPatch height and width are always equalCitation@article{dosovitskiy2020vit,
  title={An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale},
  author={Dosovitskiy, Alexey and Beyer, Lucas and Kolesnikov, Alexander and Weissenborn, Dirk and Zhai, Xiaohua and Unterthiner, Thomas and  Dehghani, Mostafa and Minderer, Matthias and Heigold, Georg and Gelly, Sylvain and Uszkoreit, Jakob and Houlsby, Neil},
  journal={ICLR},
  year={2021}
}

@misc{darcet2023vitneedreg,
  title={Vision Transformers Need Registers},
  author={Darcet, Timothée and Oquab, Maxime and Mairal, Julien and Bojanowski, Piotr},
  journal={arXiv:2309.16588},
  year={2023}
}
Package: tf-watcher
TF WatcherTF Watcheris a simple to use Python package and web app which allows you to monitor 👀 your Machine Learning training or testing process on mobile devices 📱 built specially for Google Colab, Azure ML and Kaggle. Dedicated to all ML Developers with ❤️.📄 Project DocumentationVisit the documentation of this projectto get more information in detail.💡 About the ProjectThis project includes two subprojects:🔹TF Watcher Python PackageThis is aPython Packagebuilt using TensorFlow and Pyrebase (a python wrapper for the Firebase API). This allows to eaisly monitor the metrics you want and writes them to Firebase realtime database.Navigate to/tfwatcherdirectory to browse and know more about the TF Watcher Python Package.🔹TF Watcher Web AppThis is aWeb Applicationbuilt using React, Chakra-UI, Recharts and Firebase deployed on Azure Static Web Apps. It reads from the Firebase realtime database and displays the logs using charts.Navigate to/webappdirectory to browse and know more about TF Watcher Web App.Want to Contribute 🙋‍♂️?Awesome! If you want to contribute to this project, you're always welcome! SeeContributing Guidelines. You can also take a look atTF Watcher's Project Status Trackerfor getting more information about current or upcoming tasks.Want to discuss? 💬Have any questions, doubts or want to present your opinions, views? You're always welcome. You canstart discussions.ContributorsRishit DagliShreya ParadkarHarsh SharmaLicenseCopyright 2020 Rishit Dagli

Licensed 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 at

    http://www.apache.org/licenses/LICENSE-2.0

Unless 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: tfwn
tfwnWeight Normalizationlayer wrapper for TensorFlow-Keras API.Inspired bySean Morganimplementation, but:No data initialization (only eager mode was implemented in original pull request).Code refactoringMore testsCIFAR10 example from original paper reimplementedExamplesUnfortunately I couldn't reproduce parer results on CIFAR10 with batch size 100.
As you can see there is no much difference in accuracy.But with much smaller batch size model with weight normalization is much better then regular one.How to useimporttensorflowastffromtfwnimportWeightNormdense_wn=WeightNorm(tf.keras.layers.Dense(3))out=dense_wn(input)ReferencesWeight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural NetworksTim Salimans, and Diederik P. Kingma.@inproceedings{Salimans2016WeightNorm,
  title={Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks},
  author={Tim Salimans and Diederik P. Kingma},
  booktitle={Neural Information Processing Systems 2016},
  year={2016}
}
Package: tf-word2vec
Word2VecThis is a re-implementation of Word2Vec relying on TensorflowEstimatorsandDatasets.Works with python >= 3.6 and Tensorflow v2.0.Installvia pip:pip3installtf-word2vecor, after a git clone:python3setup.pyinstallGet dataYou can download a sample of the English Wikipedia here:wgethttp://129.194.21.122/~kabbach/enwiki.20190120.sample10.0.balanced.txt.7zTrain Word2Vecw2vtrain\--data/absolute/path/to/enwiki.20190120.sample10.0.balanced.txt\--outputdir/absolute/path/to/word2vec/models\--alpha0.025\--neg5\--window2\--epochs5\--size300\--min-count50\--sample1e-5\--train-modeskipgram\--t-num-threads20\--p-num-threads25\--keep-checkpoint-max3\--batch1\--shuffling-buffer-size10000\--save-summary-steps10000\--save-checkpoints-steps100000\--log-step-count-steps10000
Package: tf-wrapper
Terraform Wrapper=================This project is intended to provide a wrapper around terraform for any projects where infrastructure might be duplicated in different environments. If you maintain different environments (dev, stage, prod) in separate regions, data centers, or different clouds this tool will help you maintain consistency across your infrastructure.The Fundamentals+++++++++++++**Requirements**you must have AWS credentials, and terraform already installed.**Project Structure**This project requires the following format:```.├── environments│   ├── dev│   │   └── dev.tf│   ├── environment_vars.json│   ├── hub│   │   └── hub.tf│   └── prod│       └── prod.tf├── main.tf└── variables.tf```In each project shared resources and variables are placed at the top level. Environment specific resources are placed under ``./environments/<environment_name>/<any files you want>``. The file ``./environment/environment_vars.json`` stores the information about your AWS remote state.**Package Use**Every time you run this package you need to specify the environment and the action. the environment is the name of the folder under ``./environments`` and the action is the typical action passed to terraform (ie. plan, destroy, apply, etc.)A sample command would be: ``tf -environment prod -action plan``**Usage Details**When you run this command the tf-wrapper will:- Symlink all files under ``./environments/<environment_name>/`` into the top level directory.- It will delete the ``.terraform/terraform.tfstate`` and ``.terraform/terraform.tfstate.backup`` files as this project requires remote state config, negating the need for local copies of state after the run has completed.- For commands ``apply`` and ``destroy`` the resulting run state will automatically be pushed.
Package: tfwsdk
TFW SDK for Python developersThis package is part of our next-gen Tutorial Framework (which just an additional abstraction layer). The purpose of the project is to decrease the learning curve of creating tutorial exercises, but it requires mandatory changes in the TFW baseimage as well.UsageIn your solvable container you should prepare anapp.pylike this:fromtfwsdkimportsdkdefon_step(curent_state:int):sdk.message_send('CURRENT STATE: '+str(curent_state))defon_deploy(curent_state:int):sdk.message_send('DEPLOY BUTTON CLICKED')returnTruedefon_message_button_click(curent_state:int,button_value:str):sdk.message_send('MESSAGE BUTTON CLICKED: '+button_value)defon_ide_write(current_state:int,name_of_file:str,content_of_file:str):sdk.message_send('IDE WRITE')defon_terminal_command(current_state:int,executed_command:str):sdk.message_send('COMMAND EXECUTED: '+executed_command)if__name__=='__main__':print('🎉 SDK STARTED 🎉')sdk.start()The SDK is running in the background (with supervisor), imports yourapp.pyand executes the above functions on corresponding events. Also, it provides some really useful functions to communicate with the TFW. Naming convention is based on theapp.ymlfile:---
dashboard:
  stepToFirstStateAutomatically: true
  messageSpeed: 400 # Word per minute
  layout: web-only
  enabledLayouts:
    #- terminal-ide-web
    #- terminal-ide-vertical
    #- terminal-web
    #- ide-web-vertical
    - terminal-ide-horizontal
    #- terminal-only
    #- ide-only
    - web-only
webservice:
  iframeUrl: /webservice
  showUrlBar: false
  reloadIframeOnDeploy: false
terminal:
  directory: /home/user
  terminalMenuItem: terminal # terminal / console
ide:
  patterns: 
   - /home/user/tutorial/*
  showDeployButton: true
  deployButtonText:
    TODEPLOY:  Deploy
    DEPLOYED:  Deployed
    DEPLOYING: Reloading app...
    FAILED:    Deployment failed
Package: tfwstartr
StartRPython package for bootstrapping TFW tutorialsUsagefromtfwstartrimportStartr# Get available templatesavailable_starter_templates=Startr.get_starters()# Get supported packages for a package managerpackage_manager='pip'# Currently available: pip, npmsupported_packages=Startr.get_supported_packages(package_manager)# Get required packages for a specific starter template# The parameters can be found in _available_starter_templates_required_packages=Startr.get_starter_requirements(language_name,framework_name,starter_name,)# Bootstrap a starter project# It will generate a ZIP file that you can either#    return or saveextra_packages={'package_name_1':'version_1','package_name_2':'version_2',}withStartr()asstartr:data=startr.generate_starter(language_name,framework_name,starter_name,extra_packages,)# Return the generated template# return data# Save the generated template, e.g. extract it to a folderimportzipfilewithzipfile.ZipFile(data)asf:f.extractall('/tmp/tfwstartr')