Saravanan666/pypi-org huggingface dataset:
Package: vfo
vfo (Visualization For OpenSees)Python Commands to visualize OpenSees models and components.Install this package with,pipinstallvfoUpgrade the package with,python-mpipinstall--upgradevfoTo use this package, import the commands fromvfoinstead ofopenseespy.postprocessing. For example,# import openseespy.postprocessing.Get_Rendering as opspltimportvfo.vfoasvfoNow, use all the openseespy visualization commands (Here). For example,vfo.plot_model()USER MANUALCheck out the (Wiki) for all the commands available in openseespyvis.
Package: vformer
VFormerA modular PyTorch library for vision transformers modelsDocumentationLibrary FeaturesContains implementations of prominent ViT architectures broken down into modular components like encoder, attention mechanism, and decoderMakes it easy to develop custom models by composing components of different architecturesUtilities for visualizing attention using techniques such as gradient rolloutInstallationFrom source (recommended)gitclonehttps://github.com/SforAiDl/vformer.gitcdvformer/
pythonsetup.pyinstallFrom PyPIpipinstallvformerModels supportedVanilla ViTSwin TransformerPyramid Vision TransformerCrossViTCompact Vision TransformerCompact Convolutional TransformerVisformerVision Transformers for Dense PredictionCvTConViTViViTPerceiver IOMemory Efficient AttentionExample usageTo instantiate and use a Swin Transformer model -importtorchfromvformer.models.classificationimportSwinTransformerimage=torch.randn(1,3,224,224)# Example datamodel=SwinTransformer(img_size=224,patch_size=4,in_channels=3,n_classes=10,embed_dim=96,depths=[2,2,6,2],num_heads=[3,6,12,24],window_size=7,drop_rate=0.2,)logits=model(image)VFormerhas a modular design and allows for easy experimentation using blocks/modules of different architectures. For example, if desired, you can use just the encoder or the windowed attention layer of the Swin Transformer model.fromvformer.attentionimportWindowAttentionwindow_attn=WindowAttention(dim=128,window_size=7,num_heads=2,**kwargs,)fromvformer.encoderimportSwinEncoderswin_encoder=SwinEncoder(dim=128,input_resolution=(224,224),depth=2,num_heads=2,window_size=7,**kwargs,)Please refer to ourdocumentationto know more.Referencesvit-pytorchSwin-TransformerPVTvit-explainCrossViTCompact-TransformersVisformerDPTCvTconvitViViT-pytorchperceiver-pytorchmemory-efficient-attention
Package: vf-portalytics
# portalytics
Portable Jupyter Setup for Machine Learning.A consistent interface for creating Machine Learning Models compatible with VisualFabriq environment.Build models using our portalytics module.
The module is available as [pip package](https://pypi.org/project/vf-portalytics/), install simply by:` pip installvf-portalytics`Pay attention to the requirements because it is important for the model to be built with the ones that we support.There are [examples](https://github.com/visualfabriq/portalytics/blob/master/example_notebooks/feature_subset_example.ipynb) of how you can use portalytics. Examples for a simple model or more complex models like MultiModel.Make sure that after saving the model using portalyctis, its possible that the model can be loaded and still contains all the important information (eg. the loaded model is able to perform a prediction?)## [MultiModel and MultiTransformer](./vf_portalytics/multi_model.py)
MultiModel is a custom sklearn model that contains one model for each group of training data.
It is valuable in cases that our dataset vary a lot, but we still need to manage one model because the problem is the same.Define the groups using input parameterclusterswhich is a list of all possible groups
andgroup_colwhich is a string that indicates in which feature the groups can be found.selected_featuresgive the ability of using different features for each group.paramsgive the ability of using different model and categorical-feature transformer for each group.The Jupyter notebook [multimodel_example.ipynb](example_notebooks/multimodel_example.ipynb) contains an
end-to-end example of how MultiModel can be trained and saved using vf_portalytics Model wrapper.MultiModel can support every sklearn based model, the only thing that is need to be done is to extend
[POTENTIAL_MODELS](./vf_portalytics/ml_helpers.py) dictionary. Feel free to raise a PR.MultiTransformer is the transformer that is being used inside MultiModel to transform categorical features into numbers.
It is a custom sklearn transformer that contains one transformer for each group of training data.Can be used also separately, in the same way as MultiModel. Check [example](./tests/test_multi_model.py)MultiTransformer can support every sklearn based transformer, the only thing that is need to be done is to extend
[POTENTIAL_TRANSFORMER](./vf_portalytics/ml_helpers.py) dictionary. Feel free to raise a PR.
Package: vfsfusepy
VFS-FUSEA versioned file system based on FUSE and Git, written in Python.DescriptionVFS-FUSE is a file system that tracks every version of files, just like Git. It uses FUSE (Filesystem in Userspace) to create a user-space file system, and uses Git to store and manage file versions.RequirementsPython 3.7 or laterInstallationFrom PyPIpipinstallvfsfusepyFrom SourceClone the repository:gitclonehttps://github.com/nero19960329/VFS-FUSE.gitInstall dependencies:pipinstall-rrequirements.txtUsageTo use VFS-FUSE, you need to specify the directory of the Git repository and the mount point of the file system:vfs-fuse/path/to/git_dir/path/to/mount_point# if installed from PyPIpythonvfsfusepy/__main__.py/path/to/git_dir/path/to/mount_point# if installed from sourceWhere:git_diris the directory of the Git repository that will be used to store and manage file versions.mount_pointis the directory where the VFS-FUSE file system will be mounted.Please ensure you have write permissions on both directories.ExampleHere is an example of how to use VFS-FUSE:# Mount the file systemmkdir/data/vfs-root
mkdir/data/vfs-mount
vfs-fuse/data/vfs-root/data/vfs-mount# Go to the mount pointcd/data/vfs-mount# Create a new fileecho"Hello, World!">test.txt# View the filecattest.txt# Rename the filemvtest.txttest2.txt# Remove the filermtest2.txt# Create a new directorymkdirtest_dir# Rename the directorymvtest_dirtest_dir2# Remove the directoryrm-rftest_dir2# View the commit historygitlogIn this example, when you write to test.txt, the file system automatically commits the changes to the Git repository located at/data/vfs-root. You can then use standard Git commands to view the commit history and checkout previous versions of the file.FAQWhy not use Git directly?VFS-FUSEoffers automatic git commits for all file changes, creating a real-time version control system. It simplifies the use of git, allowing operations via a standard file system interface. Essentially, it's git made easy for everyday file operations.How to solveraise EnvironmentError('Unable to find libfuse')?You need to install the FUSE library. On Ubuntu, you can install it with the following command:sudoapt-getupdate&&sudoapt-getinstallfuseContributingWe welcome contributions to this repository! If you would like to contribute code, please take a moment to read ourcontribution guidelines.By following these guidelines, you can ensure that your contributions are in line with our coding standards and testing procedures.We appreciate your interest and look forward to your contributions!LicenseThis project is licensed under the terms of the MIT license.
Package: vfunctions-sdk
vFunctions SDKThis package offers tools to develop vFunctions inside a secure enclave.For an use case example visit theVerifiably documentationpage.InstallationTo install this library run:pip install vfunctions_sdkMercury Bank exampleimportjsonfromvfunctions_sdkimportvFunctionfromvfunctions_sdkimportconnectiondefmercury_balance_check(account_id,mercury_token,params):# Set the url for the mercury API to get the account information# Use the account idmercury_bank_url="https://api.mercury.com/api/v1/account/{}".format(account_id)# Use the mercury token for the APIheaders={"Accept":"application/json","Content-Type":"application/json","Authorization":"Bearer{}".format(mercury_token)}response=requests.request("GET",mercury_bank_url,headers=headers)mercury_data=json.loads(response.text)if"errors"inmercury_data:returnFalseifmercury_data["currentBalance"]>params["balance_threshold"]:returnTruereturnFalsedefmain():function_params=vFunction.FunctionParams()# Get the secrets from the providersecrets_bundle=connection.WsockSecretsProvider(function_params).get_secrets()# Get the necessary secretsaccount_id=secrets_bundle["mercuryBank"]["accountId"]mercury_token=secrets_bundle["mercuryBank"]["mercuryToken"]# Get the information from the mercury accountresult_value=mercury_balance_check(account_id,mercury_token,function_params.params)result_dict={"result":result_value,"balance":function_params.params["balance_threshold"]}# Send the email with the resultsfunction_params.email_results(function_params.params['email'],result_dict)if__name__=='__main__':main()
Package: vf-utils
AboutThis git repo is about a swiss knife like tool collection for usingvereinsflieger.de.
It is addresses vereinsflieger administrators faced to the task of managing datasets on this plattform (like user access management, supporting club accounting and generating statistics). For me its a private project allowing me to apply architecture and new language patterns of python next of supporting my flight clubaeroclub prina.Contentbulk_editAs first modulebulk_editsupports you with a batch-like editing function for the painfully missing "bulk edit" functionality in the web gui of vereinsflieger (like known from JIRA). The usecase is the automatisation of "monkey edits" in the platform.ExamplesChange user status (e.g. in case of flight weeks by guests)Grant (new) user permissionsToggle flight permission ("Flugfreigabe")Applying custom properties ("Mitgliedereigenschaften")Updating flight accounting properties ("Abrechnungsart")In pastI was faced with this task where I need to change hundreds of datasets. I don't want todo this manually one by one. Approx. one year ago I started this idea based onsikuli(a nice java tool for screenshot based mouse and keyboard automation). Because its screenshot based it is highly machine dependent. Thus this tool was hard to share/maintain among others.bulk_editdoes this automatisation job referencing DOM elements of the webpage within the browser engine using the libraryselenium.IMPORTANT NOTEPlease use the toolbulk_editwith care and at your own risk!The filebulk_edit/__main__.pyat the current stage of development contains hard coded the task preparation. See todo notes in source. Modify this file for your use case!Run the script only if you know what you are doing!RequirementsSeleniumuses an browser on your machine. I used it with Firefox. So next to the dependencies specified inrequirements.txt, you need the following on your machine:For Selenium and FF:Firefox installedGeckodriverGet latest release fromhttps://github.com/mozilla/geckodriver/releasesAdd the geckodriver executable to yourPATHenvironment variable.Setup Dev EnvironmentThe setup is pythonic simple. All dependencies are defined in therequirements.txt. I recommend to use thepython virtual environment:# create virtual environment in folder envpython-mvenvenv# install dependenciespipinstall-rrequirements.txtI usedvscodeas IDE. So take a look at.vscode/launch.jsonfor program entry points for starting or debugging.If you are using a different IDE (or like to start the program from command line),
please start the program as module (using thepython -moption).!Before startingbulk_editplease read the [IMPORTANT NOTE] above!# Start program by calling the modulepython-mbulk_edit
Package: vfxClientToolkit
![Python application](https://github.com/debug/vfxClientToolkit/workflows/Python%20application/badge.svg)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)### VFX Client Toolkit
___Toolset of common utilities for client-side visual effects production management that includes:Version ingestion and management tools.Notes export utilities.Email show status report system.Version packaging and upload utility.Nuke studio EDL builder.API support and easy extensibility.—#### Installation & Configuration InstructionsRun the following in shell for installation:` pip3 installgit+https://github.com/debug/vfxClientToolkit`Documentation [here.](https://debug.github.io/vfxClientToolkit)—#### IngestItFor auto ingesting of versions into Shotgun with file version management.![alt text](https://debug.github.io/vfxClientToolkit/docs/images/ingestIt_1.png“Ingest It screenshot”)Documentation & more information [here.](https://debug.github.io/vfxClientToolkit/html/tools/ingestIt.html)—#### NoteBaoEasy downloading and packaging of creative notes for vendors.![alt text](https://debug.github.io/vfxClientToolkit/docs/images/noteBao_1.png“NoteBao screenshot”)Documentation & more information [here.](https://debug.github.io/vfxClientToolkit/html/tools/noteBao.html)—#### MrFilmOutTo package ingested versions to upload or send to DI etc![alt text](https://debug.github.io/vfxClientToolkit/docs/images/mrFilmOut_1.png“MrFilmOut screenshot”)Documentation & more information [here.](https://debug.github.io/vfxClientToolkit/html/tools/mrFilmOut.html)
Package: vfxnaming
Naming Conventions LibraryInstallationpipinstallvfxnamingDocumentationNaming Conventions DocsA complete suite of tools to manage naming conventions from one or more "Rule repositories". Structure naming rules with your own custom tokens. Then use the library to solve names following those rules so your naming is consistent, and also to parse metadata from exisiting names (cus a name is basically a collection of metadata, right?)This is completely based onCopyright (c) 2017 Cesar Saezwork. I highly recommend hisWebsite-Blogand the video tutorial series on hisYouTube ChannelFull credits in theNaming Conventions Docs
Package: vfxpaths
Common processing module of VFX pathDocumentationFull help document urlhttps://github.com/VFXToolkits/vfxpathsUpdate Log1.2.0 Fixed the template variable replacement error, and added functions related to common path operations.1.1.1 Fix ability load error1.1.0 Add path global character replacement function1.0.2 Fix file read errors1.0.1 Add common file fast read/write function1.0.0 Update path template mapping and separation functionsLicenseMIT LicenseCopyright (c) 2022 VFXToolkitsPermission 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: vfxtest
vfxtestâ†’ Release NotesWhat's this about?This project is aboutmanaging a test suitefor aPython codebasethat is used inmultiple contexts.Common contexts found in a VFX production environment are:standalonePython 2.7standalonePython 3.xembedded Python interpretersinsideDCC's:Maya/mayapyHoudini/hythonNuke...Where's the benefit?DoingTest Driven Developmentin Python is fairly straight forward
utilizing packages such asunittestandmock.It's also really comfortable to get feedback about code coverage using thecoveragepackage.However...When aPython codebaseis used inside multiple contexts that do not know
each other it is quite difficult to gatheraccurate metricsabout theoverall test coverage.And this is wherevfxtesttries to fill the gap.vfxtestis just a thin wrapper aroundunittest,mockandcoveragethat let's you run atest suite for each contextand then
presents thecombined code coverageof all those tests.I basically scratched my own itch...While starting to embraceTDDin aVFX production environmentI had
this need and did not find an obvious existing solution to it.DocumentationSoon to be found onvfxtest.readthedocs.com.Stay tuned... :)'Impostor Syndrome' DisclaimerI'm really still in my first inning of the whole TDD game.Therefore I'm fully aware that I probably know barely enough to be dangerous
right now. :)If there already happens to be an existing go-to solution for this problem out
there on the interwebs, I'd love to know about it!Also if any part of this could be improved (or makes your eyes bleed) please
give me a heads up! :)That said, I hope that somebody will get some benefit out of this!Everything that encourages and helpsmaintaining a test suiteinVFXis
valuable, as far as I'm concerned... :)
Package: vfxwindow
VFXWindowQt Window class for designing tools to be compatible between multiple VFX programs.The main purpose of the class is to integrate into the program UI, but it also contains helpful features such as safely dealing with callbacks and automatically saving the window position.The intended usage is to make your window class inheritVFXWindow- which is an instance ofQMainWindow. By callingcls.show(), it will launch the correct window type based on what program is loaded, and what settings were previously saved.This is perfectly stable, but there is still plenty that needs improvement. Maya, Nuke, 3DS Max, Houdini, Blender, Substance Designer, Unreal and Fusion are currently supported, though any help to extend those would be appreciated, as well as support for any other applications.Installationpip install vfxwindowBasic Example:classMyWindow(VFXWindow):WindowID='unique_window_id'WindowName='My Window'def__init__(self,parent=None,**kwargs):super(MyWindow,self).__init__(parent,**kwargs)# Setup window here# Setup callbacks, but wait until the program is readyself.deferred(self.newScene)defnewScene(self,*args):"""Example: Delete and reapply callbacks after loading a new scene."""self.removeCallbacks('sceneNewCallbacks')ifself.maya:self.addCallbackScene('kAfterNew',self.newScene,group='sceneNewCallbacks')elifself.nuke:self.addCallbackOnCreate(self.newScene,nodeClass='Root',group='sceneNewCallbacks')if__name__=='__main__':MyWindow.show()Support / Compatibility✔️ Working  /  ❔ Untested  /  ❌ Not WorkingStandard WindowDocked WindowCallbacksTested VersionsLinuxWindowsMacOsMaya✔️✔️✔️2011-2016,2017+✔️✔️❔Maya (Standalone)✔️✔️❔✔️❔Nuke✔️✔️✔️9-12❔✔️❔Nuke (Terminal)✔️✔️❔✔️❔Houdini✔️❌❌16-19✔️✔️❔Unreal Engine✔️❌❌4.19-4.23, 5.0-5.3❌✔️❔Blender✔️❌✔️2.8-3.4❔✔️❔3ds Max✔️❌❌2018-2020❔✔️❔Substance Painter✔️✔️❌8.3✔️✔️❔Substance Designer✔️✔️❌2019.3, 7.1, 12.3✔️✔️❔Blackmagic Fusion✔️❌❌9❔✔️❔CryEngine Sandbox✔️❌❌5.7❔✔️❔Standalone Python✔️2.7 (Qt4), 3.7-3.9 (Qt5)❔✔️❔FeaturesAutomatically save/restore window positionMove window to screen if out of bounds (windows only)Keep track of callbacks to remove groups if required, and clean up on window closeKeep track of signals to remove groups if requiredDisplay a popup message that forces controlSet palette to that of another programAuto close if opening a duplicate windowClose down all windows at onceCreate dialog windows automatically attached to the application (and return data)Running with Non-Python ApplicationsCertain Windows applications have dispatch based COM interface, which will allow a link between Python and the application. Seephotoshop-scripting-pythonfor an example on how to connect to an application.Currently there is no way of launchingVFXWindowfrom inside these applications.Special ThanksBlue Zoo- I've been building this up while working thereLior Ben Horin:Simple_MayaDockingClass.py- used for main Maya docking codeFredrik Averpil:pyvfx-boilerplate- helped with palettes, Nuke, and pre-2017 Maya
Package: vgem
vgem (python edition)VerseGroup's native encryption manager adapted for python applications.FunctionEM is an efficient manager to allow for easy encryption/decryption/secure session management, without having to code for specific algorithims, as long as the client/reciever uses this same package (or alternative language equivalent).EM prefers the OOP approach, in order to reduce the amount of key passing and similar tedious tasks. Simply initiate an EM instance empty to generate a new set of keys, or pass in existing keys (serialized or object formatted) to use. Supports mainly RSA assymetric encryption, but also hybrid encryption with RSA generated fernet wrapped AES sessions.EM also provides utilities such as hashing and base64 encoding.RSA and Fernet-AES explainedRSA is assymetric encryption, which uses private and public keys to send encrypted messages. Private keys can decrypt messages and public keys can only encrypt messages. A server wishing to recieve encrypted messages would distribute its public keys freely, and then decrypt incoming messages with its' private key. For two-way encryption, two servers would each send eachother their public keys, and decrypt messages with their private keys.Symmetric keys is less secure as it uses one key that can both encrypt and decrypt. RSA is efficient and more secure than fernet, but can sometime be slow and tedious. So, hybrid encryption is an option. Both servers use their RSA keys to send eachother a symmetric key to use (fernet key) and they then communicate with that fernetkey that only they know (this uses RSA to securly send over the symmteric key).vgem's EM class supports both use cases.How to UseThrough terminal with an activated virtualenv:pip install vgemIn python:from vgem import EMThen you have access to the EM class.Example usage of RSA:from vgem import EM

handler = EM()

message = "A very secret message"

encrypted_message = handler.encrypt(message)

private_key = handler.serialize_private_key()

handler2 = EM(serialized_private_key = private_key)

decrypted_message = handler2.decrypt(encrypted_message)

assert message == decrypted_messageDocumentationclass EMutils subdir for alternative approach (OOP prefered instead though)AttributesRSA private keyRSA public keyFernet objectFernet keyConstructionOptional Paramaters:RSA private keyRSA public keySerialized RSA private keySerialized RSA public keyFernet keyEncrypted fernet keyEM will construct anything else essential and not passed inMethodsSerialize private/public RSA keysEncrypt/Decrypt using RSA keysLoad new fernet sessionsEncrypt/Decrypt using fernet sessionSerialize/Deserialize RSA encrypted fernet keysBase64 encoding option for all encrypting and serializationNewhashing and salting!
Package: vgengine
# Python Video Game EngineA Python Video Game Engine powered by Pygame and Pymunk.Make sure to runpython setup.py install.A game engine is essentially an SDL wrapper with a Physics Engine tied together with a robuts API of generalized Game Objects and Components.Because of this, the component/system implementation of this engine resulted in three main systems:PhysicsGraphicsControlCoincidentally, this is essentiallyModelViewControltheexamplesdirectory contains a working example of how to use the game engine, the components, and ultimately playing a rendering a simple scene that uses physics and graphics.