Saravanan666/pypi-org huggingface dataset:
Package: rayid
RayIDRayIDis a generated code that we use to track logs, posts or events. You can generate your own rayid, but we made your job easier!In this instructure you will learn about how to use this package in your apps.Table of contentLanguagesInstallationmethodsDevelopmentLanguagesI created rayid forJavaScripttoo.GitLabNpmInstallationHow to installRayID? To install this package, usepiporpipenv.$pip3installrayid# Or$pipenvinstallrayidConfigSo, import the package.fromrayidimportRayIDrayid=RayID("digit")Now create your instance with what kind of rayid you want.digit: Numberslower: Alphabet in lower case.upper: Alphabet in upper case.all: Combine of all types.No type means all combined togather.rayid=RayID("digit")MethodsOnly one method!gen(len).gen(len)ingen(len)just say the length.There is no limit :)id=rayid.gen(25);print(id);# 9514992619709220193874433ExamplesCreate common instances.all=RayID("all");# All valuesstr=RayID("lower");# Loercase generatorint=RayID("digit");# Only int generatorNow use them:print(all.gen(10));# Z*jVQ3c:+Hprint(str.gen(10));# ksixvpqohiprint(int.gen(10));# 4748182066All done!DevelopmentIf you want to develop the package, it is so simple. just follow steps below.Clone the projectStart changing!Before you start:Remember the base or code are stored inrayid/rayid.py. You need to edit there.Cloning the projectTo clone the project, you need to have git installed. Ok, now clone it same as command below.$gitclonehttps:#github.com/BlackIQ/rayidChangingTo change package or anything, your need a testing environment to use linked package. Just changerayid/rayid.py.TestYour test app is linked. Change anything in package and test it intest.pyfile.
Package: rayim
Ray-Image🚀 Fast image compression for large number of images with Ray library.Requirements🐍Python>=3.7⚡Ray>=1.0.0To installray, run*:pip install ray*For Apple Silicon (M1), follow the instructionshereto installray.⬇️ Installationpip install rayim⌨️ Usageusage: rayim [-h] [-o OUTPUT_DIR] [-q QUALITY] [--overwrite] [-n] [-j]
             [--replicate-dir-tree] [-s SIZE SIZE] [-d DIV_BY] [-S] [-O]
             path [path ...]

positional arguments:
  path                  Path to a single file/directory or multiple
                        files/directories

options:
  -h, --help            show this help message and exit
  -o OUTPUT_DIR, --output-dir OUTPUT_DIR
                        Output directory (default: next to original file)
  -q QUALITY, --quality QUALITY
                        Output image quality (JPEG only; default: 70)
  --overwrite           Overwrite the original image
  -n, --no-subsampling  Turn off subsampling and retain the original image
                        setting (JPEG only)
  -j, --to-jpeg         Convert the image(s) to .JPEG
  --replicate-dir-tree  Replicate the source directory tree in the output
  -s SIZE SIZE, --size SIZE SIZE
                        Resize the image to WIDTH HEIGHT
  -d DIV_BY, --div-by DIV_BY
                        Divide the image size (WxH) by a factor of n
  -S, --silent          Silent mode
  -O, --optimize        Apply default optimization on the image(s)
  -k, --keep-date       Keep the original modification date📕 ExamplesRunning on a single file:rayimfoo.jpg# 🚀 foo.jpg: 1157. kB ==> 619.9 kB (-46.4%) | 0.07sRunning on a folderfooand writing the output tocompressedrayimfoo/-ocompressed# (compress_many pid=612778) 🚀 foo.jpg: 988.9 kB ==> 544.8 kB (-44.9%) | 0.08s# (compress_many pid=612828) 🚀 bar.jpg: 983.7 kB ==> 541.2 kB (-44.9%) | 0.07s# (compress_many pid=612826) 🚀 foobar.jpg: 1001. kB ==> 550.7 kB (-44.9%) | 0.07s# (compress_many pid=612786) 🚀 barfoo.jpg: 1001. kB ==> 551.9 kB (-44.8%) | 0.08s# ...# Total:#    Before: 1091.32 MB#    After: 599.46 MB (-45.0%)Speed comparisonTest 1 (on Apple Silicon M1, 8-cores)MethodNumber of filesSpeedRegular compression1,00060.090srayim1,00026.937s(55.17%faster)Total:Before:1091.32 MBAfter:599.46 MB (-45.0%)Test 2 (on Intel @ 2.299GHz, 32-cores)MethodNumber of filesSpeedRegular compression6,0007m42.919srayim6,0005m15.423s(31.96%faster)Total:Before:6040.59 MBAfter:3321.70 MB (-45.0%)
Package: raykit
raykitraykit is a python toolkit including a diverse set of useful functions for fast-prototyping in research, which is developed byAnyi Rao.For fun only🏖️Install with One LinepipinstallraykitVersion explanationraykit with version odd e.g.0.0.3is for simple usage, while version even e.g.0.0.4is for pytorch-based usage. you can specifiy it with e.g.pip install raykit==0.0.3Requirementspytorchis needed for even number version.How to UseFor lazinessfrom raykit.package import *Usually when we start a python program, we need to import a lot of packages such asargparse, os, os.path as osp, numpy as npetc. Just simply usefrom raykit.package import *, you get all.Basic folder operationWhen you are at the terminal, you want to check a file quickly but you don't have a GUI. Use the following. Withread_txt_list, read_json, read_pkl, you read a txt as list or a json as dict or a pickle as it be.mmcvhave the the similar functionalities, such asmmcv.load('test.json'), mmcv.load('test.yaml'), mmcv.load('test.pkl')but do not load txt.Withwrite_txt_list, write_json, write_pkl, you write as vice versa as above.Withget_folder_list, youos.listdirand output the list to a desired location.Withmkdir_ifmiss, you do not need to useos.makedirs(,exist_ok=True).OthersWithstrcal(string,num,fill)you are able to calculate a string type data and a float or int number and zfill it.Pytorchto_numpyandto_torchquickly transfer the datatype.Referenceraykit changelog,mmcv
Package: raylib-dynamic
CFFI ABI dynamic bindings avoid the need to compile a C extension module.  They now been moved to a separate module:python3 -m pip install raylib_dynamicWarningThere have been some weird failures with dynamic bindings and ctypes bindings before and often the
failures are silent
so you don’t even know something has gone wrong and you don’t get proper stacktraces.  Also the static bindings are faster.
Therefore I personally recommend the static ones.
But the dynamic bindings have the advantage that you don’t need to compile anything to install.  You just need a Raylib DLL.The API is exactly the same as the static one documented here.  (Therefore you can’t have both modules installed at once.)  The only difference is you can’t do:from raylib import *Instead you have to do:from raylib import rlThen you access the functions withrl.prefix.Seehttps://github.com/electronstudio/raylib-python-cffi/blob/master/dynamic/test_dynamic.pyfor an example.If you use therl.prefix then code will work on both static and dynamic bindings.TipIf you access functions viaimport pyraythen there is no difference at all, but be warned this hasn’t been tested much.NoteStandard Raylib DLLs do not include additional libraries like Raygui, Physac, etc.  So these functions won’t work.ImportantIf your system already has the Raylib library installed, you can set the environment variableUSE_EXTERNAL_RAYLIBand it will
always be used instead of the bundled DLLs.
Package: raylib-py-flat
Raylib-py FlatWrapsRaylib-pyand flattens the modules to a single import.Installationpip install raylib-py-flatDependenciesraylib-py(using theraylibpy-3.7branch)Demoimport raylib as rl

def main():
    rl.init_window(800, 450, "raylib [core] example - basic window")
    rl.set_target_fps(60)

    while not rl.window_should_close():
        rl.begin_drawing()
        rl.clear_background(rl.RAYWHITE)
        rl.draw_text("Congrats! You created your first window!", 190, 200, 20, rl.LIGHTGRAY)
        rl.end_drawing()

    rl.close_window()

if __name__ == '__main__':
    main()BSD 3-Clause LicenseCopyright (c) 2021, Adam Griffiths
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Package: raymond
raymondUtility package for raymond specific functions.DocumentationPlease refer to thedocumentationfor installation instructions and API usage.Citing raymondIf you use raymond in your research please use the following BibTeX entry and any BibTeX entries for used functions.@misc{rk2020raymond,author={Raymond Kirk},title={raymond},howpublished={\url{https://github.com/RaymondKirk/raymond}},year={2020}}
Package: raynet
This python pachage provides the code that accompanies our CVPR 2018 paper with
titleRayNet: Learning Volumetric 3D Reconstruction with Ray Potentials.Dependencies & InstallationNormally, apip install raynetshould suffice to use our code.If you already have a functional Keras installation there are not much left to
install :-)Keras> 2TensorflowCythonPyCudabackports.functools_lru_cacheimageiogoogleapiclientnumpymatplotlibDepending on how you want to use our code, there are two alternatives regarding
installation. You can either use a package manager or download and install the
library manually. For those who just want to use the library we recommend to
directly install the latest version fromPyPI, whereas for those who want to
be able to edit the code we recommend to install the library manually.Install from Pypi with:pipinstall--userraynetInstall manually:Clone thelatest versionof the library and run# Clone the repositorygitclonegit@github.com:paschalidoud/raynet.gitcdraynet# Local installation in development modepipinstall--user-e.DocumentationThe dedicated documentation page can be found in ourdocumentation sitebut you can also read thesource codeto get an
idea of how our code can be used. If you have any question regarding the code
please contactDespoina Paschalidou.ContributionContributions such as bug fixes, bug reports, suggestions etc. are more than
welcome and should be submitted in the form of new issues and/or pull requests
on Github.Relevant ResearchBelow we list some papers that are relevant to the provided code.OursRayNet: Learning Volumetric 3D Reconstruction with Ray Potentials [pdf]By OthersTowards Probabilistic Volumetric Reconstruction using Ray Potentials [pdf]Patches, Planes and Probabilities: A Non-local Prior for Volumetric 3D Reconstruction [pdf]Semantic Multi-view Stereo: Jointly Estimating Objects and Voxels [pdf]Learned Multi Patch Similarity [pdf]SurfaceNet: An End-to-end 3D Neural Network for Multiview Stereopsis [pdf]CitationIf you are using our code, please citeour paper.The BibTeX reference is:@InProceedings{Paschalidou_2018_CVPR,
   author = {Paschalidou, Despoina and Ulusoy, Osman and Schmitt, Carolin and Van Gool, Luc and Geiger, Andreas},
   title = {RayNet: Learning Volumetric 3D Reconstruction With Ray Potentials},
   booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
   month = {June},
   year = {2018}
   }
Package: rayon
I am the Lorax.  I speak for the trees.
–Dr. Seusslorax implements a queued web service for calculating phylogenetic trees for
gene families.  Lorax usesHMMERto do multiple sequence alignments,FastTreeorRAxMLto calculate trees,RQto queue calculations, andFlaskto serve up results.Latest ReleaseGitHubLicenseDocumentationTravis BuildCoveragePythonicityCode GradeDependenciesWorking OnIssues
Package: rayoptics
ray-opticsInstallationTo installrayopticsusing pip, use> pip install rayopticsAlternatively,rayopticscan be installed from the conda-forge channel using conda> conda install rayoptics --channel conda-forgeDocumentationThe documentation forray-opticsis hosted atRead the DocsTools for image forming optical design and analysisRayOptics is a Python geometrical optics and image forming optics library. It provides a geometric ray tracing foundation for the analysis of image forming and coherent optical systems. A number of standard geometrical analysis options such as transverse ray and wavefront aberration analysis are provided on this base. Paraxial layout of optical systems is also supported by y-ybar diagrams and graphical editing of paraxial rays in lens layout views. Import of Zemax .zmx and CODEV .seq files is supported. RayOptics can be used in Python scripts, the Python and IPython shells, the Jupyter notebook, and a Qt-based graphical user interface application.NoteThis project has been set up using PyScaffold 4.3. For details and usage information on PyScaffold seehttps://pyscaffold.org/.
Package: raypier
Raypier is a non-sequential ray-tracing framework for modelling optical systems. Its main features are:It’s pretty fast. The tracing algorithms are written in Cython (i.e. C) and use efficient data-structures for handling many thousands of rays.Correctly handles polarisationSupport for dispersion including a comprehensive library of glass-types (taken from refractive-index.info)
and diffraction-gratingsPoint Spread Function (PSF) and E-Field evaluation by summation of of Gaussian modes.Paraxial Gaussian mode evaluation covers generally astigmatic modes.Tracing support for conics section and general aspherics (conic + polnomial)An interactive user-interface with 3D model/ray rendering through VTK. Tracing is performed “live”.A modest selection of optic-types including singlet and achromatic doublet lenses (with AR coating), plane-mirrors,
ellipsoidal mirrors, prismsSTEP model/trace export for integration with external CAD systemsThere are still a few “big” features missing:The documentation is not comprehensive (yet).RequirementsRaypier requires:python-3.6 (older versions work on 2.7)numpyscipytraits / traitsuiCythonMayavi (for TVTK) / VTK(Optionally) PythonOCC - for STEP export(Optionally) Chaco / Enable - for integrating line-plots into the UIInstallationThe best way to install and run Raypier is using a Conda environment.Install miniconda (or the full Anaconda distribution)Create a fresh conda-environment using the environment.yml file included
in this raypier repo.
Package: rayse
RayseA fast hp-FEA library for linear elasticity and the relaxed micromorphic model. The library exposes models for full
three-dimensional-, plane-strain- and antiplane-shear models with a common user interface.InstallationUse the package managerpipto install Rayse:pipinstallrayseUsageExample for a relaxed micromorphic model of plane-strain.
In this example, the python librarymeshzoois used to generate the mesh.fromrayse.relaxed_plane_strainimport*fromrayse.plotimport*fromrayse.constsimport*importmeshzoo# Example mesh generation with meshzooh=0.25pts,cells=meshzoo.ngon(4,int(1./h))pts,cells=pts.tolist(),cells.tolist()# Define element power and plot resolutionp=7res=5# Initialize the mesh objectmesh=Mesh(pts,cells,p)# Create a group for the outher boundaryouter=mesh.def_outer()# Initialize the computational domaindom=Dom(mesh)# Define group "outer" as the Dirichlet boundarydom.set_boundary(outer)# Get the number of degrees of freedomfree_dofs,constrained_dofs=dom.dofs()# Plot the meshsys=plot_curves(*dom.plot_sys())plot(sys).show()# Define material constantslam=11.54mu=7.69c_ec=venant(lam,mu,2)c_ecm=venant(2.*lam,2.*mu,2)mulc=1.# Set material constantsdom.set_consts(c_ec,c_ecm,mulc)# Embed a Dirichlet boundary condition on the outer groupdom.embed_bcond(lambdax,y:[sin(x),cos(y)],outer)# Set force and micro-momentdom.set_force(lambdax,y:[0.,0.])# Solvedom.solve()# Retrieve resultsdom.set_vals()# Plot resultscurves=plot_curves(*dom.plot_curves(res))surface=plot_surf(*dom.plot_disp(res),opacity=0.9)plot(curves,surface).show()# Plot the flux of the microdistorion for the y-axisflux=plot_flux(*dom.plot_flux(res,1))plot(sys,flux).show()LicenseRayse is licensed underGNU LGPLv3.This software relies on thePyO3library under
theApache-2.0license for ffi and on
therayoncrate under theMITandApache-2.0licenses for parallelism.
The library also exposes a small wrapper for thePlotlylibrary
under theMITlicense for the purpose of visualization.
Package: raysecretsproxy
Ray Secret ProxyDISCLAIMERThe Ray Secret Proxy is not an officially supported project by Ray or Anyscale.BackgroundCredentials are required for almost every application to interact with databases, external APIs, and 3rd party integrations.  Meanwhile, securely assessing, storing, and applying them within application logic poses a risk for potential credential exposure.A straightforward approach to credential management is the use of environment variables, however these variables are not encrypted and easily accessible by other processes on a machine.To combat this, vendors have created Secret Management systems to provide mechanisms securely store, manage, and leverage secrets within applications.  However, each of these systems requires intimate knowledge of the specific secret provider in order to build an application client.UsageBefore you begin, you will need to grant an IAM Role an IAM Policy that allows your Ray cluster to access your target Secrets Proxy.  It is highly recommended to only grant read and list permissions for the Secret Manager for the IAM Role attached to your Ray clusters.For information on how to use theRay Secrets Proxy, please visit ourWalkthrough notebook.ArchitectureThe Ray Secrets Proxy is an actor that can deployed within a Ray cluster and accessed as part of the Ray application to fetch credentials for 3rd parties applications, data bases, etc.The Secrets Proxy leverages a Pluggable Ray Secret Operator that conforms to a standard interface to list and fetch credentials from a third party Secrets Manager.Ray Secret OperatorsToday, there are out of the box Ray Secret Operators for AWS and GCP Secret Managers.  These Operators are based off of theRaySecretOperatorclass and implement the following methods:initialize: a public method that initializes the client within the Proxy Actor to connect to your 3rd party Secret Store_fetch: the private method that retrieves a secret from the underlying Secret Providorget_secret: the public method to return a RaySecret from the providerlist_secrets: the public method to return a list of secrets from the providerAdditional Secret Managers can be added by implementing additional operators based off of the base Ray Secret Operator.
Package: raysql
RaySQL: DataFusion on RayThis is a research project to evaluate performing distributed SQL queries from Python, usingRayandDataFusion.GoalsDemonstrate how easily new systems can be built on top of DataFusion. See thedesign documentationto understand how RaySQL works.Drive requirements for DataFusion'sPython bindings.Create content for an interesting blog post or conference talk.Non GoalsBuild and support a production system.ExampleRun the following example live in your browser using a Google Colabnotebook.importrayfromraysql.contextimportRaySqlContextfromraysql.workerimportWorker# Start our clusterray.init()# create some remote Workersworkers=[Worker.remote()foriinrange(2)]# create a remote context and register a tablectx=RaySqlContext.remote(workers)ray.get(ctx.register_csv.remote('tips','tips.csv',True))# Parquet is also supported# ctx.register_parquet('tips', 'tips.parquet')result_set=ray.get(ctx.sql.remote('select sex, smoker, avg(tip/total_bill) as tip_pct from tips group by sex, smoker'))print(result_set)StatusRaySQL can run 21 of the 22 TPC-H benchmark queries (query 15 needs DDL and that is not yet supported).FeaturesMature SQL support (CTEs, joins, subqueries, etc) thanks to DataFusionSupport for CSV and Parquet filesLimitationsRequires a shared file system currentlyPerformanceThis chart shows the performance of RaySQL compared to Apache Spark forSQLBench-Hat a very small data set (10GB), running on my desktop (Threadripper
with 24 physical cores). Both RaySQL and Spark are configured with 24 executors.Note that query 15 is excluded from both results since RaySQL does not support DDL yet.Overall TimeRaySQL is ~65% faster overall for this scale factor and environment.Per Query TimeSpark is much faster on some queries, likely due to broadcast exchanges, which RaySQL hasn't implemented yet.Performance PlanI'm planning on experimenting with the following changes to improve performance:Make better use of Ray futures to run more tasks in parallelUse Ray object store for shuffle data transfer to reduce disk I/O costKeep upgrading to newer versions of DataFusion to pick up the latest optimizationsBuilding# prepare development environment (used to build wheel / install in development)python3-mvenvvenv# activate the venvsourcevenv/bin/activate# update pip itself if necessarypython-mpipinstall-Upip# install dependencies (for Python 3.8+)python-mpipinstall-rrequirements-in.txtWhenever rust code changes (your changes or viagit pull):# make sure you activate the venv using "source venv/bin/activate" firstmaturindevelop
python-mpytestBenchmarkingCreate a release build when running benchmarks, then use pip to install the wheel.maturindevelop--releaseHow to update dependenciesTo change test dependencies, change therequirements.inand run# install pip-tools (this can be done only once), also consider running in venvpython-mpipinstallpip-tools
python-mpiptoolscompile--generate-hashes-orequirements-310.txtTo update dependencies, run with-Upython-mpiptoolscompile-U--generate-hashes-orequirements-310.txtMore detailshere