Saravanan666/pypi-org huggingface dataset:
Package: rubikencryptor
Image Cryptography Based on Rubix's Cube PrincipleImplementation of image encryption and decryption using Rubix's Cube Principle. This algorithm is based on the paper"A Secure Image Encryption Algorithm Based on Rubik's Cube Principle"by Khaled Loukhaoukha, Jean-Yves Chouinard and Abdellah Berdai.Algorithm OverviewGiven an input image having the three R,G,B matrices of sizeM X NHyperparameters includeα- used for vector creationITER_MAX- maximum number of times to carry out operationsA. EncyptionCreate two vectorsKrandKcwith|Kr|=M&|Kc|=N. The values of these vectors are randomly picked from 0 to 2α-1Repeat below stepsITER_MAXnumber of timesi.Rolling Rows:The sum of all pixel values of every row of the image RGB matrices are calculated one by one.If the sum of a given rowrowNumberis even, Roll the row to the rightKr[rowNumber]times
Otherwise roll to the leftKr[rowNumber]times.ii.Rolling Columns:The sum of all pixel values of every column of the image RGB matrices are calculated one by one.If the sum of a given rowcolumnNumberis even, roll the column upKc[columnNumber]times.
Otherwise roll the column downKc[columnNumber]times.iii.XORing Pixels:For every pixel(i,j), XOR the pixel with the below two valuesValue #1 -Kc[columnNumber]ifiis odd else 180 rotated bit version ofKc[columnNumber]Value #2 -Kr[rowNumber]ifjis even else 180 rotated bit version ofKr[rowNumber]B. DecryptionGiven an encrypted image, vectorsKrandKc&ITER_MAX, decryption can be done by following the reverse procedure - XORing pixels → Rolling Columns → Rolling RowsITER_MAXnumber of timesPrerequisitesPython3 (https://www.python.org/downloads/)Python3 package dependencies - Runpip3 install -r requirements.txtRunningUsing the crypto_client.py script supplying neccessary parameters$ python3 crypto_client.py -h
usage: crypto_client.py [-h] [--type TYPE] [--image IMAGE] 
      [--alpha ALPHA] [--iter_max ITER_MAX] 
      [--key KEY] [--output_image OUTPUT_IMAGE]Using rubikencryptor python packagefrom rubikencryptor.rubikencryptor import RubikCubeCrypto
from PIL import Image

# Encrypt image
input_image = Image.open('image1.png')
encryptor = RubikCubeCrypto(input_image)
encrypted_image = encryptor.encrypt(alpha=8, iter_max=10, key_filename='key.txt')
encrypted_image.save('encrypted_image.png')

# Decrypt image
decryptor = RubikCubeCrypto(encrypted_image)
decrypted_image = decryptor.decrypt(key_filename='key.txt')
decrypted_image.save('decrypted_image.png')Example -Original ImageRun Encryption on the Original Image$ python3 crypto_client.py --type encrypt
    --image example/original.png 
    --output_image example/encrypted.png 
    --key example/encoded_key.txt 
    --alpha 8 --iter_max 10encrypted image is stored atexample/encrypted.png& key is stored atexample/encoded_key.txtEncrypted ImageRun Decryption on the Encryped Image using the Key$ python3 crypto_client.py --type decrypt  
    --image example/encrypted.png 
    --output_image example/decrypted.png 
    --key example/encoded_key.txtdecrypted image is stored atexample/decrypted.pngDecrypted Image -
Package: rubiks-cube-gym
RubiksCubeGymAn OpenAI Gym environment for various twisty puzzles.Currently available environments:2x2x2 Pocket Rubik's CubePyraminxSkewbCitation@article{hukmani2021solving,
  title={Solving Twisty Puzzles Using Parallel Q-learning.},
  author={Hukmani, Kavish and Kolekar, Sucheta and Vobugari, Sreekumar},
  journal={Engineering Letters},
  volume={29},
  number={4},
  year={2021}
}Details:2x2x2 Pocket Rubik's CubeAction SpaceDiscrete(3)Observation SpaceDiscrete(3674160)ActionsF, R, URewards(-inf, 100]Max steps250Reward TypesBase, Layer By Layer Method, Ortega MethodRender Modes'human', 'rgb_array', 'ansi'Pyraminx without tipsAction SpaceDiscrete(4)Observation SpaceDiscrete(933120)ActionsL, R, U, BRewards(-inf, 100]Max steps250Reward TypesBase, Layer by Layer MethodRender Modes'human', 'rgb_array', 'ansi'SkewbAction SpaceDiscrete(4)Observation SpaceDiscrete(3149280)ActionsL, R, U, BRewards(-inf, 100]Max steps250Reward TypesBase, Sarah's Method(Advanced)Render Modes'human', 'rgb_array', 'ansi'InstallationVia PyPIpip install rubiks-cube-gymOr build from sourcegit clone https://github.com/DoubleGremlin181/RubiksCubeGym.git
cd RubiksCubeGym
pip install -e .Requirementsgymnumpyopencv-pythonwgetScramblingYou can pass the scramble as a parameter for the reset functionself.reset(scramble="R U R' U'")The scramble should follow theWCA NotationExampleimport gym  
import rubiks_cube_gym  
  
env = gym.make('rubiks-cube-222-lbl-v0')  
env.reset(scramble="R U R' U' R' F R2 U' R' U' R U R' F'")  
  
for _ in range(4):  
    env.render()  
    print(env.step(1))  
env.render(render_time=0)  
env.close()(3178426, -26, False, {'cube': array([ 0,  9,  2, 15,  4,  5,  6, 21, 16, 10,  1, 11, 12, 13, 14, 23, 17, 7,  3, 19, 20, 18, 22,  8], dtype=uint8), 'cube_reduced': 'WRWGOOGYRBWBOOGYRGWBYBYR'})
(1542962, -1, False, {'cube': array([ 0, 21,  2, 23,  4,  5,  6, 18, 17, 16, 15, 11, 12, 13, 14,  8,  7, 10,  9, 19, 20,  3, 22,  1], dtype=uint8), 'cube_reduced': 'WYWYOOGBRRGBOOGRGBRBYWYW'})
(1682970, -1, False, {'cube': array([ 0, 18,  2,  8,  4,  5,  6,  3,  7, 17, 23, 11, 12, 13, 14,  1, 10, 16, 21, 19, 20,  9, 22, 15], dtype=uint8), 'cube_reduced': 'WBWROOGWGRYBOOGWBRYBYRYG'})
(2220193, 25, False, {'cube': array([ 0,  3,  2,  1,  4,  5,  6,  9, 10,  7,  8, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], dtype=uint8), 'cube_reduced': 'WWWWOOGRBGRBOOGGRRBBYYYY'})You can find my implementation and results using Parallel Q-learninghere.
Package: rubik-sim
Rubik SimThis project allows to simulate a 3x3 Rubik's cube and perform operations over it.⚙️ SetupRequirementsPython 3.9 or higherInstallationThe package is installable via pip:pipinstallrubik-simAlternatively, the 'develop' branch can be installed for the latest changespipinstallgit+https://github.com/Jtachan/genetic_rubiks_solver.git@develop🏃 UsageInitializing the cubeThe package allows importing all the classes directly from the module.To initialize the cube, it is only needed theRubiksCubeclass.
This generates a fully solved cube. To obtain a random state usingscramble()fromrubik_simimportRubiksCubemy_cube=RubiksCube()# Solved cubemy_cube.scramble()# Updates the cube by 25 random movesThe number of moves to scramble the cube can also be specified as a parameter:RubiksCube.scramble(nof_moves: int = 25)It is also possible to initialize any cube from a string of characters defining the color of each tile.my_cube=RubiksCube.from_color_code('BBBBBBBBBGGGGGGGGGOOOOOOOOOYYYYYYYYYRRRRRRRRRWWWWWWWWW')The only supported colors are green ('G'), orange ('O'), yellow ('Y'), red ('R'), white ('W') and blue ('B').RepresentationThe cube's state can be represented by callingprint()>>>print(my_cube)['B' 'B' 'B']['B' 'B' 'B']['B' 'B' 'B']['G' 'G' 'G']['O' 'O' 'O']['Y' 'Y' 'Y']['R' 'R' 'R']['G' 'G' 'G']['O' 'O' 'O']['Y' 'Y' 'Y']['R' 'R' 'R']['G' 'G' 'G']['O' 'O' 'O']['Y' 'Y' 'Y']['R' 'R' 'R']['W' 'W' 'W']['W' 'W' 'W']['W' 'W' 'W']From the representation, the faces are:Blue = Top (up) faceGreen = Left faceOrange = Front faceYellow = Right faceRed = Back faceWhite = Bottom (down) faceRotating the cubeRubiksCube.perform_operations(operations: Sequence[NOTATION_MOVES])This method updates the current state of the cube by performing operations over it.
The supported operations are:U, U', U2, D, D', D2, R, R', R2, L, L', L2, F, F', F2, B, B', B2,
M, M', M2, E, E', E2, S, S' and S2.These are the general notations for the possible moves on the cube.
More about the Rubik's cube notation:https://ruwix.com/the-rubiks-cube/notation/Any missing notation can be performed with the current notations.
Package: rubik-solver
Rubik Cube solving library and command line utilityHow to install$ pip install rubik_solverHow to useAs a commandAs a module>>>cube='wowgybwyogygybyoggrowbrgywrborwggybrbwororbwborgowryby'>>>fromrubik_solverimportutils>>>utils.solve(cube,'Beginner')[F', R, U',R', U, U, F2, Y, B',U,B,U,F2,Y,R', F',U,F,R,U,U,U,F2,Y,L,F,U', F',L', U, F2, Y, L',U,L,U', R, U, R',Y,U', F',U', F, Y, B, U, B',R,U,R', Y, Y, U',L', U, L, U, F, U',F', Y, Y, U2, Y2, U, R, U',R', U',F', U, F, Y, Y, U, R, U',R', U',F', U, F, Y, F, R, U, R',U', F',U2,F,R,U,R', U',F', F, R, U, R',U', F',U,U,U,U,R,U', L',U,R', U',L,R', D',R,D,R', D',R,D,U,R', D',R,D,R', D',R,D,U,U,R', D',R,D,R', D',R,D,U]>>>utils.solve(cube,'CFOP')[F', R, U',R', U, U, F2, Y, B',U,B,U,F2,Y,R', F',U,F,R,U,U,U,F2,Y,L,F,U', F',L', U, F2, Y, L',U,L,U', U, F',U,F,U,F', U2, F, Y, U, Y',R', U',R,U2,R', U',R,U,R', U',R,Y,Y,B,U,B', U, F',U2,F,U,F', U2, F, Y, U2, U',R,U,R', U, R, U, R',Y,Y,R', F, R, U, R',F', R, Y, L, U',L', U, Y, Y, Y, Y, U, Y, Y, Y, Y, U, Y, Y, R, U',R,U,R,U,R,U', R',U', R2]>>>utils.solve(cube,'Kociemba')[L', F, B2, R',B,R', L, B, D',F', U, B2, U, F2, D',R2,L2,U,F2,D']Cube NotationFor a better and more in depth explanation about the cube moves notation visithttps://ruwix.com/the-rubiks-cube/notation/The configuration string of the cube corresponds to the color of the stickers according to the following figure----------------
               | 0  | 1  | 2  |
               ----------------
               | 3  | 4  | 5  |
               ----------------
               | 6  | 7  | 8  |
               ----------------
-------------------------------------------------------------
| 9  | 10 | 11 | 18 | 19 | 20 | 27 | 28 | 29 | 36 | 37 | 38 |
-------------------------------------------------------------
| 12 | 13 | 14 | 21 | 22 | 23 | 30 | 31 | 32 | 39 | 40 | 41 |
-------------------------------------------------------------
| 15 | 16 | 17 | 24 | 25 | 26 | 33 | 34 | 35 | 42 | 43 | 44 |
-------------------------------------------------------------
               ----------------
               | 45 | 46 | 47 |
               ----------------
               | 48 | 49 | 50 |
               ----------------
               | 51 | 52 | 53 |
               ----------------So, the color at position 0, corresponds to the color of the sticker BLU, the color at 1 is BU and so on …Colors used in the implementation are:[O]range[B]lue[R]ed[W]hite[Y]ellow[G]reenNOTEKociembasolver needs the following cubies at place:4(Upper center):YELLOW13(Left center):BLUE22(Front center):RED31(Right center):GREEN40(Back center):ORANGE49(Down center):WHITETODOImprove documentationImprove Kociemba Solver tests
Package: rubin-kubespawner
kubespawner(jupyterhub-kubespawner @ PyPI)Thekubespawner(also known as JupyterHub Kubernetes Spawner) enables JupyterHub to spawn
single-user notebook servers on aKubernetescluster.See theKubeSpawner documentationfor more
information about features and usage. In particular, here isa list of all the spawner options.FeaturesKubernetes is an open-source system for automating deployment, scaling, and
management of containerized applications. If you want to run a JupyterHub
setup that needs to scale across multiple nodes (anything with over ~50
simultaneous users), Kubernetes is a wonderful way to do it. Features include:Easily and elasticly run anywhere between 2 and thousands of nodes with the
same set of powerful abstractions. Scale up and down as required by simply
adding or removing nodes.Run JupyterHub itself inside Kubernetes easily. This allows you to manage
many JupyterHub deployments with only Kubernetes, without requiring an extra
layer of Ansible / Puppet / Bash scripts. This also provides easy integrated
monitoring and failover for the hub process itself.Spawn multiple hubs in the same kubernetes cluster, with support fornamespaces. You can limit the
amount of resources each namespace can use, effectively limiting the amount
of resources a single JupyterHub (and its users) can use. This allows
organizations to easily maintain multiple JupyterHubs with just one
kubernetes cluster, allowing for easy maintenance & high resource
utilization.Provide guarantees and limits on the amount of resources (CPU / RAM) that
single-user notebooks can use. Kubernetes has comprehensiveresource controlthat can
be used from the spawner.Mount various types ofpersistent volumesonto the single-user notebook's container.Control various security parameters (such as userid/groupid, SELinux, etc)
via flexiblePod Security Policies.Run easily in multiple clouds (or on your own machines). Helps avoid vendor
lock-in. You can even spread out your cluster acrossmultiple clouds at the same time.In general, Kubernetes provides a ton of well thought out, useful features -
and you can use all of them along with this spawner.RequirementsKubernetesEverything should work from Kubernetes v1.6+.TheKube DNS addonis not strictly required - the spawner usesenvironment variablebased discovery instead. Your kubernetes cluster will need to be configured to
support the types of volumes you want to use.If you are just getting started and want a kubernetes cluster to play with,Google Container Engineis
probably the nicest option. For AWS/Azure,kopsis probably the way to go.Getting helpWe encourage you to ask questions on theJupyter mailing list.
You can also participate in development discussions or get live help onGitter.LicenseWe use a shared copyright model that enables all contributors to maintain the
copyright on their contributions.All code is licensed under the terms of the revised BSD license.ResourcesJupyterHub and kubespawnerReporting IssuesDocumentation for JupyterHubDocumentation for JupyterHub's REST APIJupyterDocumentation for Project Jupyter|PDFProject Jupyter website
Package: rubin-squarebot
SquarebotSquarebot is the nexus service for ChatOps and event-driven bots for Rubin Observatory.
As a Slack app, Squarebot receives events from Slack and publishes them into specificSquare EventsKafka topics in theRoundtable Kubernetes cluster.
Other applications on Roundtable can consume these events and act on them, such as by posting messages back to Slack or by performing some other background automation.flowchart LR
    subgraph Slack
    message[Slack message]
    interaction[Slack interaction]
    end
    subgraph sqrbot ["Squarebot"]
    eventapi["/slack/event"]
    interactionapi["/slack/interaction"]
    message -->|HTTP POST| eventapi
    interaction -->|HTTP POST| interactionapi
    end
    subgraph kafka ["Kafka Topics"]
    topicmention["lsst.square-events.squarebot.slack.app.mention"]
    topicchannel["lsst.square-events.squarebot.slack.message.channel"]
    topicgroup["lsst.square-events.squarebot.slack.message.group"]
    topicim["lsst.square-events.squarebot.slack.message.im"]
    topicmpim["lsst.square-events.squarebot.slack.message.mpim"]
    topicinteraction["lsst.square-events.squarebot.slack.interaction"]
    end
    eventapi --> topicmention
    eventapi --> topicchannel
    eventapi --> topicgroup
    eventapi --> topicim
    eventapi --> topicmpim
    interactionapi --> topicinteraction
    subgraph backends ["Backends"]
    backend1["Backend 1"]
    backend2["Backend 2"]
    end
    topicchannel --> backend1
    topicgroup --> backend1
    topicmention --> backend2
    topicinteraction --> backend2Slack integration is implemented at the time.
We plan to add support for other event sources, such as GitHub, in the future.Squarebot is built on top ofFastAPI, a modern Python web framework, with the Rubin/SQuaRESafirlibrary.
Squarebot usesFastStreamto publish messages to Kafka with theaiokafkalibrary.Development set upSquarebot uses Python 3.12 or later.You'll neednoxto run the development environment:pipinstallnoxThen you can set up a virtual environment with the development dependencies:nox-svenv-init`(If you already have a virtual environment, you can activate it and runnox -s initinstead).The tests require a local Kafka broker.
If you have Docker, you can deploy a Kafka broker with Docker Compose:docker-compose-fkafka-compose.yamlupTo run all linters, type checking, and tests, run:noxWhile developing and running tests, you can inspect messages produced to Kafka with Kafdrop athttp://localhost:9000.You can run individual sessions withnox -s <session-name>.
Seenox -lfor a list of available sessions.To tear down the Kafka broker, run:docker-compose-fkafka-compose.yamldown
Package: rubip
An example:fromrubipimportrubipproxies={'https':'https://localhost:8080'}bot=rubip("Auth Account",proxies=proxies)gap="guids"bot.sendMessage(gap,"pyrubika")How to import the Rubik's libraryfromrubipimportrubipHow to install the librarypipinstallrubipMy ID in Rubika@mamadcoder1And My ID Channel in Rubika@python_java_source
Package: rubiran
An example:fromrubiranimportrubirankey=""auth=""bot=rubiran(auth,key)gap="guids"bot.sendMessage(gap,"rubiran")###how to install librarypipinstallaiohttp
pipinstallpycryptodome
pipinstallpillowHow to import the Rubik's libraryfromrubiranimportrubiranHow to install the librarypipinstallrubiran==2.1.0My ID in Rubika@professor_102And My ID Channel in Rubika@python_java_source
Package: rubithon
homerubithon for rubika client, python 3 | milad heidaridocument•githubRubika Client for python 3installpip install rubithonexmapleimportasynciofromrubithonimportClient,models,handlersasyncdefmain():asyncwithClient(session='rubika')asclient:@client.on(handlers.MessageUpdates(models.author_guid()==client._guid))asyncdefupdates(update):awaitupdate.reply('`hello` __from__ **rubika**')awaitclient.run_until_disconnected()asyncio.run(main())methodsclassYou can find the list of methods in themethods.jsonThe list of methods is divided into 9 groups, which are:users,chats,extras,groups,messages,channels,conracts,settings,stickers,authorisationsThe output of all methods is a dictionary that you must give to thecallmethodExamplefromrubithonimportClient,methodsclient=Client(...)result=awaitClient(methods.users.GetUserInfo(user_guid='...'))Example to get the list of methods of a groupfromrubithonimportmethodsprint(dir(methods.users))Example of getting the list of arguments of a methodfromrubithonimportmethodsprint(methods.users.SetBlockUser)RaisesTypeError: if the data type is inconsistent with the allowed values typesValueError: if the value does not exist in the allowed listhandlersclassIncluding 5 classes (may be increased) which are:ChatUpdates,MessageUpdates,ShowActivities,ShowNotifications,RemoveNotificationsThese are used to filter updates, whose names indicate what type of update they receive.The inputs of these classes aremodels, If __any is true, OR operator is placed between the filters, otherwise ANDFilters can be functions Examplefromrubithonimporthandlersasyncdefcustom_filter(update,result):returnupdate.raw_texthandlers.MessageUpdates(custom_filter)TipsFilters can be functionsBetween the filters you can use the operators|,&,!=,==,>,>=,<,<=useTo use the operators, the filter (model) must be calledmodelsclassIncluding 3 classes,  which are:Operator,BaseModels,RegexModelYou can use all the attributes of the update, the most important of which have already been writtenExamplesasyncdefcustom_filter(update,result):returnresulthandlers.MessageUpdates('hi'!=models.raw_text())handlers.MessageUpdates(custom_filter!=models.raw_text())handlers.MessageUpdates(custom_filter==models.time(func=int))handlers.MessageUpdates(models.RegexModel(pattern=r'hi'))Multiple Filters (AND)handlers.MessageUpdates((15<models.time(func=int)>10)&models.RegexModel(pattern=r'hi')&models.is_private)# orhandlers.MessageUpdates(15<models.time(func=int)>10,models.RegexModel(pattern=r'hi'),models.is_private)Multiple Filters (OR)handlers.MessageUpdates(models.is_private|(models.author_guid()=='GUID'))# orhandlers.MessageUpdates(models.is_private,models.author_guid()=='GUID',__any=True)Get updates (add handler)asyncwithClient(session='rubika')asclient:@client.on(handler)asyncdefupdates(update):pass# orasyncwithClient(session='rubika')asclient:asyncdefupdates(update):passclient.add_handler(updates,handler)✌ در آرزوی جهانی  ...
Package: rubix
[![PyPI version](https://badge.fury.io/py/rubix.svg)](https://badge.fury.io/py/rubix)### What is Rubix?Python library that makes it easy to perform common DevOps tasks inside Jupyter Notebooks. E.g. plot Cloudwatch metrics, rollback your ECS/kubernetes app etc.### When to use it?While Rubix can be used in many contexts, it's most useful for writing incident runbooks/playbooks. On-call can read instructions & execute steps right from the Jupyter Notebook. I wrote more about the use case [here](https://hackernoon.com/simplify-devops-with-jupyter-notebook-c700fb6b503c).### Why Jupyter Notebook?- Jupyter allows interleaving instructions and executable code. Ideal for quick incident response.- Rich HTML output makes it easy to plot graphs, show deployment status etc.- Low friction way to edit/view/execute notebooks in a browser.# Live In ActionCheckout this 1-minute debugging session to see how Rubix helped root cause API latency issue.[![Demo Video](https://uploads-ssl.webflow.com/5adf07174a787c7249ade79f/5b0cfeb0db589c364b44ee72_Video_Thumbnail_2.png)](https://www.youtube.com/watch?v=vvLXSAHCGF8&rel=0&autoplay=0 "API Latency Demo")# DocumentationCurrently following integrations are supported in Rubix, would love to add more. Note that Jupyter Notebook supports executing [shell commands](http://docs.nurtch.com/en/latest/nurtch-platform/index.html#run-shell-commands-in-notebook) & [SQL queries](http://docs.nurtch.com/en/latest/nurtch-platform/index.html#run-sql-queries-in-notebook) out of the box.* [Rubix](http://docs.nurtch.com/en/latest/rubix-library/index.html)* [Cloudwatch](http://docs.nurtch.com/en/latest/rubix-library/aws/cloudwatch.html)* [Elastic Container Service (ECS)](http://docs.nurtch.com/en/latest/rubix-library/aws/ecs.html)* [Kubernetes](http://docs.nurtch.com/en/latest/rubix-library/kubernetes.html#api-usage)# InstallationRubix exclusively works with Jupyter notebooks. You can [install Jupyter](http://jupyter.org/install) locally or use [JupyterHub](https://jupyterhub.readthedocs.io/en/stable/#) multi user setup. I also built built [nurtch](http://nurtch.com) (commercial) for easy multi user Jupyter setup.* For your Jupyter/JupyterHub setup, just execute the following at the top of any notebook. Bang operator tells Jupyter to execute this as a terminal command.```!pip install rubix```* Rubix is pre-installed with [nurtch](http://nurtch.com) multi-user Jupyter setup.# UsageComplete documentation is linked above. Here are some usage examples.### Plot Cloudwatch Metrics![Cloudwatch Metrics Example](http://docs.nurtch.com/en/latest/_images/plot_metric_example.png)### Rollback Service in ECS![ECS Rollback Example](http://docs.nurtch.com/en/latest/_images/ecs_rollback.png)# ContributeIf you see any problem, open an issue or send a pull request. For additional integrations open an issue with `Feature Request` tag & clearly describe the operations you want to perform. You can write to me at [amit@nurtch.com](mailto:amit@nurtch.com) or DM me on [twitter](https://twitter.com/amittrathi).
Package: rubix-admin
# Admin Tool for Rubix# Installationrubix-adminshould be installed on the cluster (Presto/Hadoop2) mastergit clonehttps://github.com/qubole/rubix-admin.gitvirtualenv venv
source venv/bin/activate
python setup.py install
rubix-admin -h# Configure Admin Toolrubix-adminexpects a configuration file at~/.radminrc. If you followed
the instruction in the previous section, it should already be present.
If the configuration file does not exist, run:rubix-admin -hEdit the configuration file.# Install Rubix
Generate a Rubix RPM by following the instructions in Qubole Rubix project.rubix-admin installer install –rpm <path to rpm># Start Rubixrubix-admin daemon start
Package: rubix-api
# Rubix APIA proprietary api for external python projects.## InstallationYou can install the Rubix API from [PyPI]():pip install rubix_apiThe api is tested only on Python 3.6.## How to useRubix API is a toolkit of python modules to help interacting with rubix .NET projects, [Rubix](https://github.com/rubix-labs/Rubix).### RubixAuthIntroduces custom Oauth2 authentication mechanism, it can be integrated with [requests](https://github.com/kennethreitz/requests) as describedin [new forms of authentication](http://docs.python-requests.org/en/master/user/authentication/#new-forms-of-authentication).from rubix_api.auth import RubixAuthrubix_auth = RubixAuth("https://hostname/connect/token","client_id","client-secret","grant_type","audience")requests.get("https://api/endpoint", auth=rubix_auth)