Saravanan666/pypi-org huggingface dataset:
Package: blend360-all-star-clickstream-api
de-allstar-training-clickstream-apiAPI package to request clickstream dataUsageclickstream_apimodule contains the classdatafetch.DataFetch, which can be instantiated to send api requests to fetch data from an endpoint, check a job status, or query the number of visitors per day.In order to run theDataFetchmodule you must first instantiate aDataFetchobject. Upon your first time running the module you will be given a prompt to enter your API key. This will save your API key to your local keyring so you will not be asked for you API key again.DatabricksIn order to run on a databricks cluster you must first add your API key to Databricks. Copy and run the code below in your terminal to add your API key.$databrickssecretscreate-scope--scope<my-scope>
$databrickssecretsput--scope<my-scope>--key<my-key>--string-value<api_key>If running on your local machine you will be prompted to enter your API key the first time running the module. The API key will be saved to your keyring.>>>fromblend360_all_star_clickstream_api.datafetchimportDataFetch>>>data_fetch=DataFetch()EnteryourAPIKey:<api_key>>>>If the API key needs to be removed, runDataFetch.deleteAPIKey(). If the API key needs to be updated, runDataFetch.updateAPIKey().blend360_all_star_clickstream_api.datafetch.DataFetch.fetchDatafetchData(self, start_date: datetime.date, end_date: datetime.date) -> strTriggers async job that sends data to destination s3 locationArgsstart_date(datetime.date): Earliest date of clickstream data to collectend_date(datetime.date): Latest date of clickstream data to collectdestination_bucket(str): S3 bucket for data to land indestination_directory(str): Directory in S3 bucket for data to land intable_name(str): Name of table to fetchReturns:requests.models.Response:    Response object.Example:>>>data_fetch.fetchData(start_date=datetime.date(2022,1,1),end_date=datetime.date(2023,1,1),destination_bucket="clickstream-server",destination_directory="poop_test")<Response[200]>>>>data_fetch.fetchData(start_date=datetime.date(2022,1,1),end_date=datetime.date(2023,1,1),destination_bucket="clickstream-server",destination_directory="poop_test").json(){'job_id':12345}>>>clickstream_api.datafetch.DataFetch.checkStatuscheckStatus(self, job_id: int) -> strChecks on the status of the S3 copy jobArgs:job_id(int): ID of S3 copy jobReturns:requests.models.Response:    Response object.Example:>>>data_fetch.checkStatus(12345)<Response[200]>>>>data_fetch.checkStatus(12345).json(){'execution_status':'RUNNING'}>>>clickstream_api.datafetch.DataFetch.updateAPIKeyupdateAPIKey(self)Update the API KeyExample:>>>data_fetch.updateAPIKey()EnteryourAPIKey:<api_key>>>>clickstream_api.datafetch.DataFetch.deleteAPIKeydeleteAPIKey(self)Remove your API key from keyringExample:>>>data_fetch.deleteAPIKey()>>>
Package: blender
# bpy
Pre-built [Blender](https://www.blender.org/) 2.79 as a python 3.5 module bpy for linux.## Dependencies
Note that this repository requiresPython 3.5. Run [THIS](https://github.com/sobotka/blender/blob/v2.79/build_files/build_environment/install_deps.sh) script to install all Blender dependencies before installing this module.`bash wget"https://raw.githubusercontent.com/sobotka/blender/v2.79/build_files/build_environment/install_deps.sh"chmod +x install_deps.sh ./install_deps.sh `## Installation
To install via [pypi](https://pypi.org/project/blender/#description):`bash python3-mpip install blender `Alternatively:`bash git clonehttps://github.com/uzairakbar/blender.gitpython3-mpip install path/to/cloned/repo `## Usage`bash from blender import bpy `
Package: blender-downloader
blender-downloaderMultiplatform Python CLI utility that downloads a specific portable release of
Blender by version/os/bits from official Blender repositories. The minimum
supported version is v2.57.Installpipinstallblender-downloaderUsageExecuteblender-downloader --helpto see all supported arguments.Download release by version numberblender-downloader2.92Download current stable releaseblender-downloaderstableDownload stable release, extract/mount and printblenderexecutable locationblender-downloaderstable--extract--print-blender-executableList all available versions to downloadblender-downloader--list
Package: blendernc
BlenderNCBlenderNCis an open source add-on and Python module to visualizenetCDF,grib, andzarrdatasets inBlender.BlenderNC builds uponxarrayanddaskto lazy load, manipulate, and display datasets as images in Blender.Why BlenderNC?Science visualization is a fundamental part of science communication and the exploration of large datasets. However, production quality real-time visualization and animation of scientific data has remained unreachable to the scientific community. BlenderNC main goal is to facilitate the generation of quality animations of scientific gridded data with a powerful and simple interface. For example:Quick load of datasets:Nodes tree for more complex visualizations:Math computations in BlenderNC node tree.DocumentationLearn more about BlenderNC in the official documentation athttps://blendernc.readthedocs.ioContributingAll contributions, bug reports, bug fixes, documentation improvements, enhancements, and ideas are welcome. More information about contributing to BlenderNC can be found at ourContribution page.Use Github to:report bugs,suggest features,provide examples,and view the source code.SupportBlenderNCis supported by:To implement and improve support of weather and climate data visualizations in GRIB format and visualize numerical models of the global ocean and sea-ice.Authors@josuemtzmo@orioltintoContributors@whatnick@navidcy@stephansiemen
Package: blenderneuron
BlenderNEURONallows to easily visualize computational neuroscience models created usingNEURONsimulator in the 3D graphics toolsetBlender.The tool allows the visualization of neuronal trees (morphology) and simulated activity (compartment membrane potentials). It supports visualization ofsingle neuronsandnetworks. The tool was created byresearchers at Arizona State University.More examples can be seen onBlenderNEURON.organd onNeuroML-DB.orgThis Python package is Part 1 of 2 (the client), which enables NEURON to communicate with Blender. Part 2 is the Blender addon (the server), which allows Blender to process messages from NEURON. Download Part 2 fromBlenderNEURON.org.
Package: blender-notebook
Blender NotebookA simple command line tool to wrap blender 2.8+ as a jupyter kernel.Blender's python API requires its embedded python interpreter. As of Blender 2.82, python 3.7 is packaged. In order to make ipykernel and other pip packages accessible to Blender, thesite-packagesdirectory of the python interpreter executing blender_notebook will be added to Blender's python path. Therefore, it's highly recommended to use exactly the same python version as your blender.InstallationThe easiest way to install blender_notebook is via pip:$ python -m pip install blender_notebookIt can also be installed from source:$ python -m pip install -e .UsageIf blender in installed by a package manager, the easiest way to find the executable path is:$ which blender
/snap/bin/blenderIn my case, blender is installed from snap.On MacOS, the blender executable path is usually:/Applications/Blender.app/Contents/MacOS/BlenderOn Windows, the blender executable path is usually:C:\Program Files\Blender Foundation\Blender 2.82\blender.exeThen, run the blender_notebook CLI (replace"snap/bin/blender"with your blender executable path):$ blender_notebook install --blender-exec="/snap/bin/blender"
Saving files to ~/.local/share/jupyter/kernels/blenderIf you launch jupyter notebook as usual, a new kernel namedblendershould be available.$ jupyter kernelspec list
Available kernels:
blender              ~/.local/share/jupyter/kernels/blender

$ jupyter notebookYou can also delete the kernel:$ blender_notebook remove
Are you sure to delete ~/.local/share/jupyter/kernels/blender ? [y/N]: y
blender jupyter kernel is removed!
Package: blender-plot
blender-plotA High-Level Plotting Interface for Blender in Python.Install:pip install blender-plotExample:importblender_plotasbpimportnumpyasnp# create 512 normally distributed 3d pointsdata=np.random.standard_normal((512,3))s=bp.DefaultScene()s.scatter(data)# render the scene to an images.render("standard_normal.png",resolution=(1200,1200))# save the scene to a .blend files.save("standard_normal.blend")Output:
Package: blender-qt-stylesheet
Blender Qt stylesheetA Blender Qt stylesheet for PySide2, PySide6 PyQt5, PyQt6 (using qtpy)The top 3 images are this style in PySide6 & PySide2Blender PySide6Blender PySide2Blender PySide2 + dark title barnotice bug with dial and scrollbarDefault qt stylePySide6 fusion styleInstructionsimportblender_stylesheetblender_stylesheet.setup()seeexample/example.pyFeaturesapply dark style to QApplicationapply Blender Icon to QApplicationDark title bar in PySide2Optional in PySide2: Make your title bar dark when creating your QApplicationHappens automatically in PySide6app=QApplication(sys.argv+['-platform','windows:darkmode=2'])Ported the original stylesheet from theBQtproject, to allow stylesheet use outside Blender.
Package: blender-stubs
Blender / UPBGE API StubsThis module provides type information forBlenderandUPBGE's Python API, following thePEP-561standard.It was generated usingBPY Stub Generatorwhich
is also available onPyPIas a separate module.ScreenshotsAuto-completion at work in PyCharm:Pop-up documentation support in VSCode:InstallationThere are two variants of the API stubs, one for Blender and the other for UPBGE. For Blender,
you can installblender-stubsmodule with appropriate version qualifier as follows:$pipinstallblender-stubs==3.1.26This will install the latest module for Blender 2.93, and for now stubs are provided for Blender
2.80 and onwards. You can also specify the next unreleased version as3.1.*to get the latest
snapshot of the module:$pipinstallblender-stubs==3.2.*A stub module for UPBGE 0.3, as well as pre-release versions for the master branch are also
available on PyPI repository. For the stable version, you can install it as follows:$pipinstallupbge-stubs==0.3.0.26And for the latest snapshot,$pipinstallupbge-stubs==0.3.1.*You can also install the module usingPipenv. Note that it is required to setallow_preleasesoption
in case you want to install a snapshot release (e.g. UPBGE 0.3.1.*).You can use the following content as a template for yourPipfile:[[source]]name="pypi"url="https://pypi.org/simple"verify_ssl=true[packages]"upbge-stubs"="==0.3.1.*"[requires]python_version="3.10"[pipenv]allow_prereleases=trueYou may want to use[dev-packages]instead of[packages]as it's more appropriate to do so,
in which case you can install or update the stubs using the-dflag likepipenv update -d.LicenseThis project is provided under the terms ofGNU General Public License v3 (GPL3).
Package: blendersynth
Documentation|GitHub|PyPIBlenderSynth is a Python library for generating large scale synthetic datasets usingBlender. Compared to other tools, BlenderSynth provides support for:CustomShader AOVsto render rich per-pixel information;node control;multithreadingsupport; andmultiviewrendering support.UsageSee documentation forinstallation,debugging/troubleshootingandexamples.BlenderSynth supports Blender 3 and 4.Contributions and ProjectsThis project is currently in Beta. Please let me know what new features you would like, or feel free to make a pull request!If you use BlenderSynth for a project, pleasecontact meabout it - I might include it in the documentation as a usage example!CitingIf you use BlenderSynth in your work, please cite:@software{blendersynth,
  author       = {Ollie Boyne},
  title        = {BlenderSynth},
  year         = 2023,
  publisher    = {GitHub},
  url          = {https://ollieboyne.github.io/BlenderSynth},
}BenchmarkingRendering speed compared toBlenderProc:
Package: blendfig
blendfigOverviewblendfig is a Python module to be used with the 3D modeling software Blender. With blendfig you can create plots in Blender similarly to the usual Python plotting libraries such as plotly and matplotlib. You can then use Blender's powerful shading, modeling etc. features to create beautiful plots and animations.Installation<python>-mpipinstallblendfigBlender comes with its own Python installation so make sure<python>is Blender's Python binary. On Windows it is located atC:\Program Files\Blender Foundation\Blender <version>\<version>\python\bin\python.exeby default. You may need to run as administrator to install globally.UsageSyntax is similar to that of plotly.importblendfigasbfimportnumpyasnpx,y=np.mgrid[-1:1:51j,-1:1:51j]z=(x**2+y**2-1)**2fig=bf.Figure()fig.add_trace(bf.Surface(x=x,y=y,z=z))fig.create()OutputAfter some simple BlenderingCurve plotsCurves can be plotted with theScatterobject. You can plot 2D or 3D curves. Below is the Lorenz chaotic attractor as an example.deflorenz(x,y,z,s=10,r=28,b=2.667):""" Diff equation solver """x_dot=s*(y-x)y_dot=r*x-y-x*zz_dot=x*y-b*zreturnx_dot,y_dot,z_dot# initializationdt=0.01num_steps=10000xs=np.empty(num_steps+1)ys=np.empty(num_steps+1)zs=np.empty(num_steps+1)xs[0],ys[0],zs[0]=(0.,1.,1.05)# simpulate time stepsforiinrange(num_steps):x_dot,y_dot,z_dot=lorenz(xs[i],ys[i],zs[i])xs[i+1]=xs[i]+(x_dot*dt)ys[i+1]=ys[i]+(y_dot*dt)zs[i+1]=zs[i]+(z_dot*dt)# make plotcurve=bf.Scatter(x=xs,y=ys,z=zs,name='Lorenz')curve.draw()After applying some Blender effects we get a lovely roll of Hubba Bubba Bubble Tape.OutputAfter some simple BlenderingBar plotsBar plots can be created with theBarobject.importpandasaspdimportblendfigasbf# popularity of programming languagespopularity_data=pd.read_html('https://www.tiobe.com/tiobe-index/')[0]popularity_data=popularity_data[["Programming Language.1","Ratings"]].rename(columns={"Programming Language.1":"Name"})popularity_data["Ratings"]=popularity_data["Ratings"].apply(lambdax:float(x[:-1]))# make bar chartbar=bf.Bar(x=popularity_data["Name"],z=popularity_data["Ratings"])bar.draw()# add labelsbar.draw_xlabels()zlabels=popularity_data["Ratings"].apply(lambdax:f'{x}%')# add % signsbar.draw_zlabels(zlabels)OutputAfter some simple BlenderingThe bars and labels are generated with Geometry Nodes which allows for more customization. Selecting bars/labels and clicking on theModifierstab will show the following controls. Also the materials have to be set in these windows.barsx labelsz labels
Package: blendify
IntroductionBlendify is a lightweight Python framework that provides a high-level API for creating and rendering scenes with Blender. Developed with a focus on 3D computer vision visualization, Blendify simplifies access to selected Blender functions and objects.Key features of Blendify:Simple interface: Blendify provides a user-friendly interface for performing common visualization tasks without having to dive into the complicated Blender API.Easy integration: Blendify seamlessly integrates with development scripts, implementing
commonly used routines and functions:native support of point clouds, meshes, and primitives;support of per-vertex colors and textures;advanced shadows with shadow catcher objects;video rendering with smooth camera trajectories;support for common camera models;import and export of .blend files for deeper integration with Blender.Quick start: Blendify is easy to get started with and does not require a standalone Blender installation. All you need to do is runpip install blendify.Installation instructionsInstall from pippipinstallblendifyOptional requirementspipinstallblendify[utils/examples/docs/all]Running examples 4 and 5 requiresPyTorchwithPyTorch3D.Running example 5 requires SMPL model files, please refer to the installation instructions inREADME.Quick Start# Script to render cubefromblendifyimportscenefromblendify.materialsimportPrincipledBSDFMaterialfromblendify.colorsimportUniformColors# Add lightscene.lights.add_point(strength=1000,translation=(4,-2,4))# Add camerascene.set_perspective_camera((512,512),fov_x=0.7,quaternion=(0.82,0.42,0.18,0.34),translation=(5,-5,5))# Create materialmaterial=PrincipledBSDFMaterial()# Create colorcolor=UniformColors((0.0,1.0,0.0))# Add cube meshscene.renderables.add_cube_mesh(1.0,material,color)# Render scenescene.render(filepath="cube.png")ExamplesCheck examples in our repositoryhere.Works that use blendifyV. Lazova, E. Insafutdinov, G. Pons-Moll:360-Degree Textures of People in Clothing from a Single Imagein 3DV'19B.L. Bhatnagar, X. Xie,I. Petrov, C. Sminchisescu, C. Theobalt, G. Pons-Moll:BEHAVE: Dataset and Method for Tracking Human Object Interactions, in CVPR'22X. Zhang, B.L. Bhatnagar,V. Guzov, S. Starke, G. Pons-Moll:COUCH: Towards Controllable Human-Chair Interactions, in ECCV'22G. Tiwari, D. Antic, J. E. Lenssen, N. Sarafianos, T. Tung, G. Pons-Moll:Pose-NDF:
Modeling Human Pose Manifolds with Neural Distance Fields, in ECCV'22I. Petrov, R. Marin, J. Chibane, G. Pons-Moll:Object pop-up: Can we infer 3D objects and their poses from human interactions alone?, in CVPR'23ContributorsBlendify is written and maintained byVladimir GuzovandIlya Petrov.AcknowledgmentsWe thank Verica Lazova for providing her Blender rendering scripts.
Our code for processing point clouds is mostly based on the amazingBlender-Photogrammetry-Importeraddon.LicenseThe code is released under theGNU General Public License v3.The Python logo is trademark of Python Software Foundation.
The Blender logo is a registered property of Blender Foundation.Blender-Photogrammetry-Importeris distributed under theMIT License.
Blender is released under theGNU General Public License v3.
Package: blending_toolkit
BlendingToolKitFramework for fast generation and analysis of galaxy blends catalogs. This toolkit is a convenient way of
producing multi-band postage stamp images of blend scenes.Documentation can be found athttps://lsstdesc.org/BlendingToolKit/index.htmlWorkflowColor code for this flowchart:Classes in black should be used as is by the user.Classes in red may be reimplemented by the experienced user; we recommend for new users to use the default implementations until they are familiar with them.In blue is the code for instantiating the classes within the code (optional arguments not included).In green are the revelant methods for the classes; please note that the__call__method is executed when calling the object (egsampling_function(catalog)) and the__next__method is executed when usingnext(egnext(generator)).Running BlendingToolKitBlendingToolKit (btk) requires an input catalog that contains information required to simulate galaxies and blends.
This repository includes sample input catalogs with a small number of galaxies that can be used to draw blend images with btk. Seetutorialsto learn how to run btk with these catalogs.CatSim Catalog corresponding to one square degree of sky and processed WeakLensingDeblending catalogs can be downloaded fromhere.Cosmo DC2catalog requires pre-processing in order to be used as input catalog to btk. Refer to thisnotebookon how to convert the DC2 catalog into a CatSim-like catalog that can be analyzed with btk.InstallationBTK is pip installable, with the following command:pip install blending_toolkitAlthough you might run into problems installinggalsim. In case of any issues, please see the more detailed installation instructionshere.For required packages, seepyproject.tomlunder the[tool.poetry.dependencies]block. For developers, you will also need the packages under the[tool.poetry.dev-dependencies]block.ContributingSeeCONTRIBUTING.md
Package: blend-lib
`Blend <http://blend.readthedocs.org/en/latest/>`_ is a Python (2.6 or higher)library for interacting with `BioCloudCentral.org`_, `CloudMan`_, and `Galaxy`_'sAPI. Conceptually, it makes it possible to script and automate the process ofcloud infrastrucutre provisioning and scaling, as well as running of analyseswithin Galaxy. In reality, it makes it possible to do things like this:- Create a CloudMan compute cluster, via an API and directly from your local machine::from blend.cloudman.launch import CloudManLaunchcml = CloudManLaunch('<your cloud access key>', '<your cloud secret key')cml.launch('Blend CloudMan', 'ami-<ID>', 'm1.small', 'password')cml.get_status()- Manipulate your CloudMan instance and react to the current needs::from blend.cloudman import CloudMancm = CloudMan("instance IP", "password")cm.initialize(type="Galaxy")cm.add_nodes(3)cluster_status = cm.get_status()cm.remove_nodes(2)- Interact with Galaxy via a straighforward API::from blend.galaxy import GalaxyInstancegi = GalaxyInstance('<Galaxy IP>', key='your API key')libs = gi.libraries.get_libraries()gi.workflows.show_workflow('workflow ID')gi.workflows.run_workflow('workflow ID', input_dataset_map).. note::Although this library allows you to blend these three services into a cohesive unit,the library itself can be used with any single service irrespective of the rest. Forexample, you can use it to just manipulate CloudMan clusters or to script theinteractions with an instance of Galaxy running on your laptop.
Package: blendpdb
blendpdb===============================================================================blendpdb is a tool for mixing two different substance to make solvate such as 50%Ethanol.Install-------------------------------------------------------------------------------Use pip or easy_install likepip install blendpdbUsage-------------------------------------------------------------------------------Usage: blendpdb SUB_A SUB_B PERCENTAGE [options]Blend PERCENTAGE (v/v) of SUB_B with SUB_AOptions:-h, --help            show this help message and exit-c FILE, --config=FILEload configure from FILE (Default '.blendrc')-v, --verbose         print informations-n, --dry             do not create blended PDB ('-v' will automatically beset)-o FILE, --output=FILEoutput blended PDB into FILE (Default<PERCENTAGE>p_<SUB_B>.pdb)`blendrc`-------------------------------------------------------------------------------To add different substance, create `blendrc` file in the working directory likeWAT:                                # Namelongname: Water                   # Long namedensity: 1                        # Density (g/cm^3)molecular_weight: 18.01           # Molecular Weight (g/mol)pdb: water.pdb                    # PDB file indicate the substanceTFE:                                # Namelongname: 2,2,2-Trifluoroethanol  # Long namedensity: 1.393                    # Density (g/cm^3)molecular_weight: 100.04          # Molecular Weight (g/mol)pdb: tfe.pdb                      # PDB file indicate the substanceblendpdb also try to load `.blendrc` file in your Home directory.
Package: blendplot
BlendplotBlendplot is a command line application for generating 3D data plots for use in Blender.$ blendplot abc.csv abc.obj period amplitude_Iband magnitude_Iband -c category 
Wrote plot file to abc.obj
Plotted 37099 points in 1.531214 secondsInstallationTo install Blendplot from source you can run the following commands.git clone https://github.com/ExcaliburZero/blender-astro-visualization.git
cd blender-astro-visualization
pip install ./UsageBlendplot allows you to generate a 3D data plot model by specifying a dataset file, the output model file (.obj), and the names of the three (x,y,z) columns you want to plot. Currently it only supports.csvinput data files. The commad structure to run blendplot is as follows.blendplot INPUT_FILE OUTPUT_FILE X Y ZFor example, to create a model from a data filedata.csvusing the columnsheight,weight, andcostand output to a filemodel.objyou would run the following command.blendplot data.csv model.obj height weight costOnce you have used the script to generate the model file, you can then import it into Blender by going toFile > Import > Wavefront (.obj)and selecting the model file.DocumentationFor futher in-depth information on how to use Blendplot, see the documentation at the link below.Blendplot - Read The DocsLicensingThe source code for Blendplot is available under theMIT License, seeLICENSEfor more information.