Saravanan666/pypi-org huggingface dataset:
Package: radcompressor
RadComp: Radial compressor mean-line modelMean-line (1D) model for evaluating radial compressors. The code is adapted
from the version developed by Schiffmann and Favrat[^1], and was used to generate
a turbo-compressor dataset forDATED.Cyril Picard, Jürg Schiffmann and Faez Ahmed, "DATED: Guidelines for Creating Synthetic
Datasets for Engineering Design Applications", 2023.[^1]: Jürg Schiffmann and Daniel Favrat, “Design, experimental investigation and multi-objective optimization of a small-scale radial compressor for heat pump applications,” Energy, vol. 35, no. 1, pp. 436–450, Jan. 2010, doi:10.1016/j.energy.2009.10.010.DatasetsThe dataset related toDATEDwill be uploaded soon.Using the modelInstallationTo install this package, first make sure that you have Python >= 3.9 installed in your environment. If not, we
recommend to install Python usingmambaforge.gitclonehttps://github.com/cyrilpic/radcompcdradcomp
pipinstall.If you want to install all dependencies to use the dataset generation scripts:pipinstall.[generate]Basic UsageA step-by-step example is provided in theEvaluateCompressor.ipynb notebook.CitationIf you use the dataset or the model, you can cite our publication:Cyril Picard, Jürg Schiffmann and Faez Ahmed, "DATED: Guidelines for Creating Synthetic
Datasets for Engineering Design Applications", 2023.
Package: raddish
RaddishRaddish is mix of RPC and job queue backed by Redis. You can launch multiple servers that will accept the same function calls in a round-robin fashion. From the client side you can asynchronously submit jobs and block the execution until they are completed.Getting startedImplement a serverimportasyncioimportloggingimportosfromredis.asyncioimportRedisfromrich.loggingimportRichHandlerfromraddishimportRaddishServer,AsyncWorkerlogging.basicConfig(level=logging.INFO,format="%(message)s",datefmt="[%X]",handlers=[RichHandler(rich_tracebacks=True)],)logger=logging.getLogger("raddish-test")classTestWorker(AsyncWorker):asyncdefsetup(self)->None:logger.info("Setting up test worker")asyncdef__call__(self,input:dict[str,any])->dict[str,any]:logger.info(f"Received input:{input}")input:int=input["number"]input+=1awaitasyncio.sleep(10)return{"number":input,}asyncdefmain()->None:redis_client:Redis=Redis.from_url(os.environ.get("REDIS_URL","redis://localhost:6379"))server:RaddishServer=RaddishServer(redis_client)server.add_worker("add_one",TestWorker())awaitserver.start()if__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(main())Implement a clientimportasyncioimportloggingimportosfromredis.asyncioimportRedisfromrich.loggingimportRichHandlerfromraddishimportAsyncRaddishClientlogging.basicConfig(level=logging.INFO,format="%(message)s",datefmt="[%X]",handlers=[RichHandler(rich_tracebacks=True)],)logger=logging.getLogger("raddish-test")asyncdefmain()->None:redis_client:Redis=Redis.from_url(os.environ.get("REDIS_URL","redis://localhost:6379"))client:AsyncRaddishClient=AsyncRaddishClient(redis_client)counter:int=0for_inrange(5):logger.info(f"Sending input{counter}")counter=(awaitclient.call("add_one",{"number":counter}))["number"]logger.info(f"Received output{counter}")if__name__=="__main__":loop=asyncio.get_event_loop()loop.run_until_complete(main())Launch one or more serverspythonserver.pyLaunch one or more clientspythonclient.pyFeaturesYou can add servers at any time in order to increase capacityAsyncio-nativeServers can be located anywhere where there is internet, no need to have public ip - you only need to be able to connect to the redis serverLicenseRaddish is licensed under Apache License, Version 2.0
Package: radexreader
RadexReaderThe RadexReader is an user-space driver for theRADEX RD1212 v1/v2and theRADEX ONEGeiger counters. It allow to read and clear stored data via USB. Warning! This tool is completely unrelated with QuartaRad.This tool was initially developed with RD1212 v2.48.Screenshots and UsageReadsrc/radexreader.pyfor examples.Run the commandradexreaderavailable with DEB/RPM packages.Run the command.../radexreader.pyavailable with PYPI package.InstallationIt requirelibusb,pyusbandpyserial.Installation for Debian and Ubuntusudo apt install python3-radexreader radexreaderInstallation for Fedorasudo dnf install python3-radexreaderInstallation for openSUSEsudo zypper install python3-radexreaderInstallation with PIPWith Linux:sudo python3 -m pip install radexreader(+libusb)With Mac:sudo pip install radexreader(+libusb)With Windows:python -m pip install radexreader(+libusb, put libusb-1.0.dll in system32)Installation with Dockersudo docker run --rm --user root -it --privileged -v /dev:/dev python:3.x-alpine /bin/shthen:apk update ; apk add libusb ; python3 -m pip install radexreaderRepository for Debian and Ubuntu# PPA: https://launchpad.net/~luigifab/+archive/ubuntu/packages# with Debian 12+ you can use mantic+ instead of focal (https://unix.stackexchange.com/a/669008/364800)sudoadd-apt-repositoryppa:luigifab/packages
sudoaptupdate
sudoaptinstallpython3-radexreaderradexreader# orsudoapt-keyadv--keyserverhkp://keyserver.ubuntu.com:80--recv-keysFFE5BD439356DF7Decho"deb http://ppa.launchpad.net/luigifab/packages/ubuntu focal main"|sudotee-a/etc/apt/sources.list
sudoaptupdate
sudoaptinstallpython3-radexreaderradexreader# orsudowget-O/etc/apt/trusted.gpg.d/luigifab.gpghttps://www.luigifab.fr/apt.gpgecho"deb http://ppa.launchpad.net/luigifab/packages/ubuntu focal main"|sudotee-a/etc/apt/sources.list
sudoaptupdate
sudoaptinstallpython3-radexreaderradexreader# sha256sum /etc/apt/trusted.gpg.d/luigifab.gpg578c89a677048e38007462d543686b53587efba9f93814601169253c45ff9213# apt-key list/etc/apt/trusted.gpg.d/luigifab.gpg
pubrsa40962020-10-31[SC]458B0C46D024FD8CB8BC99CDFFE5BD439356DF7DCopyrightCurrent version: 1.2.4 (02/02/2024)Compatibility: Python 3.3 / 3.4 / 3.5 / 3.6 / 3.7 / 3.8 / 3.9 / 3.10 / 3.11 / 3.12Links:luigifab.fr-github.com-PyPIArch Linux python-radexreader.zstDebian python-radexreader.deb(ITP,RFS)Fedora python-radexreader.rpmopenSUSE python-radexreader.rpmUbuntu PPAThis program is provided under the terms of theGNU GPLv2+license.If you like, take some of your time to improve some translations, go tohttps://bit.ly/2HyCCEc.Packages in official distros repositories
Package: radheef
RadheefPython library for getting the meaning of a dhivehi word and other related informationinstallationpip install radheefUsage examplefromradheefimportradheefprint(radheef("ބަރު"))returnsނ. 1 ލުއިގެ އިދިކޮޅު. 2 ވަޒަނުން އިތުރު. 3 ބައެއް ގަޑި ހިނގާއިރު އެލިފައި ހުރެގެން ދެފަރާތަށް ހެލިހެލި ހުންނަ އެތި. 4 ކަރުދާސް ވަޔާ ހިނގައިދާނެތީ އޭގެ މަތީ ބަހައްޓާން ގެންގުޅޭ ތަކެތި. 5 ސަންޑޯކުރާ ބަރު އުފުލަން ގެންގުޅޭ އެކި ވަރުގެ އާލާތް. 6 ނއ. މަސައްކަތް ބޮޑު.Note: argument must be passed in as thaana
Package: radiacode
RadiaCodeОписание на русском языкеThis is a library to work with the radiation detector and spectrometerRadiaCode-101.The project is still under development and not stable. Thus, the API might change in the future.Example project (backend,frontend):Installation and example projects# install library together with all the dependencies for the examples, remove [examples] if you don't need them
$ pip3 install 'radiacode[examples]' --upgrade

# launch the webserver from the screenshot above
# bluetooth: replace with the address of your device
$ python3 -m radiacode-examples.webserver --bluetooth-mac 52:43:01:02:03:04
# or the same, but via usb
$ sudo python3 -m radiacode-examples.webserver

# simple example for outputting information to the terminal, options are similar to the webserver example
$ python3 -m radiacode-examples.basic

# send data to the public monitoring project narodmon.ru
$ python3 -m radiacode-examples.narodmon --bluetooth-mac 52:43:01:02:03:04Developmentinstallpython poetryclone this repositoryinstall and run:$ poetry install
$ poetry run python3 radiacode-examples/basic.py --bluetooth-mac 52:43:01:02:03:04 # or without --bluetooth-mac for USB connection
Package: radial
💫 RadialAn intiutive interface for your requests in secondsRadial abstracts painful low-levels request handling and presents a simple and intiutive interface to handle requests for your application.Example@radial("https://dog.ceo/api")classDog:@get("/breeds/image/random")defrandom(self,response):returnresponse.json()dog=Dog()random=dog.random()print(random)Currently work in progress
Package: radial-basis-function
Radial Basis Function: Regressão e Classificação facilitados por MatrizesRBF propõe uma alternativa de cálculo matricial aos seus modelos de Regressão, Séries Temporais, Classificação e Convolução.InstalaçãoPara instalar a biblioteca na sua máquina, pelo prompt ou shell.pip install radial-basis-functionPara usar a dependencia no código python.import radial_basis_functionMatriz Pseudo-InversaMultiplicação de Matriz Pseudo-Inversa, que é operado como alternativa no lugar da otimização por derivadas parciais. Refere-se a uma abordagem matemática chamada de "fórmula de Moore-Penrose", onde a matriz pseudo-inversa é utilizada para encontrar os coeficientes ótimos da equação de regressão. É uma generalização da matriz inversa para casos em que a matriz não é inversível (ou seja, singular), e a fórmula fornece uma maneira de obter uma solução única mesmo quando a matriz não é invertível.Para usar a dependencia no código python, foram criados os métodos fit e predict com nome inspirados nos moldes do Sklearn.# Instancia do modelo
modelo_pseudo_inversa = radial_basis_function.PseudoInversa()

# Treinando o modelo
modelo_pseudo_inversa.fit(Matriz_X, y)

# Previsão do modelo
predicao = modelo_pseudo_inversa.predict(Matriz_X)

# Para métrica de previsão utilize uma biblioteca já existente como sklearn.metrics
from sklearn import metrics

# Como:
metrics.mean_absolute_error(Y_Treino, predicao)
metrics.r2_score(Y_Treino, predicao)
metrics.accuracy_score(Y_Treino, predicao)
metrics.balanced_accuracy_score(Y_Treino, predicao)
metrics.f1_score(Y_Treino, predicao)Radial Basis FunctionA estrutura básica de um Radial Basis Function (RBF Network) consiste em três componentes principais: as funções de base radial, os pesos associados a essas funções e uma camada de saída linear solucionada pela matriz pseudo-inversa.Para usar a dependencia no código python, foram criados os métodos fit e predict com nome inspirados nos moldes do Sklearn.# Instancia do modelo
modelo_rbf = radial_basis_function.RadialBasisFunction()

# Treinando o modelo
modelo_rbf.fit(Matriz_X, y)

# Previsão do modelo
predicao = modelo_rbf.predict(Matriz_X)

# Para métrica de previsão utilize uma biblioteca já existente como sklearn.metrics
from sklearn import metrics

# Como:
metrics.mean_absolute_error(Y_Treino, predicao)
metrics.r2_score(Y_Treino, predicao)
metrics.accuracy_score(Y_Treino, predicao)
metrics.balanced_accuracy_score(Y_Treino, predicao)
metrics.f1_score(Y_Treino, predicao)TestesTeste sendo desenvolvido para Jupyter Notebookby Victor Venites
Package: radialdf
Radial Distribution FunctionThis package provides the radial distribution function to analyze the radial density of
particles around other particles. The package provides a single functioninner_rdfthat
calculates the RDF but excludes the border regions (as they would require n-dimensional
intersection of shapes, which isn't computationally feasible).A future version, if my short attention span permits it, will provide anrdffunction
that handles the 2D and 3D cases with the inclusion of the border regions.Examplefromradialdfimportinner_rdfimportnumpyasnpimportplotly.graph_objsasgo# Generate 10000 random particles with 3 coordinates between 0 and 100particles=np.random.rand(10000,3)*100# Define a volume from 0 to 100 on 3 axesbox=[[0,100]]*3# Check the radial distribution, which should be pretty boring and flatg=inner_rdf(box,particles,20,0.2)go.Figure(go.Scatter(x=[i*0.2foriinrange(21)],y=g)).show()
Package: radial-distance-layout
# Radial Distance LayoutGenerates a radial layout for trees whose nodes are associated with a distance to the root, similar to how it has been done in [1]. You can choose the basic method or a more sophisticated version which makes a more efficient use of space.[1] *The Hidden Geometry of Complex, Network-Driven Contagion Phenomena*, D Brockmann, D Helbing, Science Vol. 342, Issue 6164, pp. 1337-1342 (2013)## Install$ sudo python setup.py install## Example$ python example.pyor look here:```#!pythonfrom radial_distance_layout import radial_distance_layoutimport matplotlib.pyplot as plimport networkx as nxpaths  = [ [ 'a','b','c'] ]paths += [ [ 'a','b','d'] ]paths += [ [ 'a','e','f','g'] ]paths += [ [ 'a','e','f','h'] ]paths += [ [ 'a','e','i'] ]paths += [ [ 'a','j','k'] ]paths += [ [ 'a','j','l'] ]dists = {'a': 0,'b':1.1, 'e': 1.2, 'j': 1.4,'c':2.1, 'd': 2.2, 'f': 2.1, 'i': 2.34, 'k':3.8, 'l':2.5,'g': 3.9, 'h': 3.8}#The Tree has to be a DiGraph! The root is always the one with distance 0.T = nx.DiGraph()for p in paths:T.add_path(p)keystr = 'dist'nx.set_node_attributes(T,keystr,dists)fig,ax = pl.subplots(1,2,figsize=(15,8))pos = radial_distance_layout(T,keystr,mode='soph')nx.draw_networkx(T,pos,ax=ax[0])pos = radial_distance_layout(T,keystr,mode='normal')nx.draw_networkx(T,pos,ax=ax[1])pl.show()```
Package: radialx
IntroductionRadialX is a python package for working with x-ray
powder diffraction data and for simulating
x-ray powder diffraction patterns from models.The most complete documentation is available athttp://pythonhosted.org/radialx/.Fully Documented FunctionalitiesAt present, the only 100% documented functionalities of RadialX areThe simulation of powder diffraction patterns
from PDB files using the utility calledpowderx.Displaying of diffraction image header information
using the utility calledheaderx.Detailed usage forpowderxandheaderxare
explained within thedocumentation.Less Documented FunctionalitiesOther less documented functionalities correspond to “modes” of the
utility calledprofilex:centeringmode: Finding the centers of powder diffraction images
inadxvbinary format.averagingmode: Radial integration of one or
more experimental powder diffraction patterns inadxvbinary format.averagingmode: Scaling of several powder experimental or simulated
diffraction patterns to a single experimental or simulated pattern.differencemode: Calculating the difference of two scaled
radially integrated experimental powder diffraction patterns.Althoughprofilexis fully functional and heavily tested, its
user interface (i.e. config file format, etc.) is very likely to
change. For example, the modes will probably be split into different
different utilities and several config file parameters will
probably be renamed. Theprofilexutility is fairly well documented by
comments in the config files that populate thetest/test-profilexdirectory of the source distribution, as explained in thedocumentation.It is hoped that the entire RadialX package will be fully
and heavily documented soon.Home Page & RepositoryHome Page:https://pypi.python.org/pypi/radialx/Documentation:http://pythonhosted.org/radialx/Repository:https://github.com/jcstroud/radialx
Package: radiance
Radianceprovides a simple way to output to light displays.
A python library is provided for easy implementation on your device or middleware.
All you have to do is instantiate a LightOutputNode and point it to your device.Example deviceTo try it out, run it in the background. Then, open Radiance and create a newLightOutputNodepointing atlocalhost.
Add a full-screen pattern such aspurplebefore theLightOutputNodeto fill the display with color.
You should see a circle of lights that correspond to the edges of the frame.If you restart the server and want to reconnect, simply select theLightOutputNodeand hitR.#!/usr/bin/env python3importloggingimportmathimportradiance# This example shows how to interface custom hardware to radiance.# This basic idea here is to subclasses radiance.LightOutputNode# and override callback methods in it# with custom functionality.classExample(radiance.LightOutputNode):def__init__(self,*args,**kwargs):super().__init__(*args,**kwargs)# This tells Radiance the name of our device, and how big the sampled canvas should be.self.description={"name":"Python Example","size":[100,100]}# This would request 5 pixels at the corners and center.#self.lookup_2d([(0, 0), (0, 1), (1, 0), (1, 1), (0.5, 0.5)])# Instead, lets request 120 pixels around the border.N=30self.lookup_2d=[(0,i/N)foriinrange(N)]self.lookup_2d+=[(i/N,0)foriinrange(N)]self.lookup_2d+=[(1,1-i/N)foriinrange(N)]self.lookup_2d+=[(1-i/N,1)foriinrange(N)]# If we stopped here, Radiance would visualize this display using the lookup coordinates# and show a square.# If the physical display looks different, we tell Radiance about it with the# "physical coordinates" command.# Lets tell Radiance to visualize the points as a circle instead.defmoveToCircle(x,y):l=math.hypot(x-0.5,y-0.5)return(0.5*(x-0.5)/l+0.5,0.5*(y-0.5)/l+0.5)self.physical_2d=[moveToCircle(x,y)for(x,y)inself.lookup_2d]# We can send radiance a PNG file to be used as a background image for visualization.# This logo image is not very useful, but perhaps some line-art of your venue would work well.#with open("../resources/library/images/logo.png", "rb") as f:#    self.geometry_2d = f.read()# Ask for frames from Radiance every 20 ms (50 FPS).# On flaky connections, set this to zero.# Doing so will request frames one-by-one in a synchronous manner,# which will avoid network congestion.self.period=20# This gets called every time a frame is received.defon_frame(self,frame):# This is where you would output to LED strips# or whatever hardware you have.# For now, lets just print out the RGB values for the first few pixels# to the console.# Print the RGB values for the first few pixels to the consoleprint(frame[0:5])# Turn on logging so we can see debug messageslogging.basicConfig(level=logging.DEBUG)# Construct our devicedevice=Example()# Start it goingdevice.serve_forever()
Package: radianceQuantifier
A image processing pipeline to automatically crop and quantify tumor burdens (radiance) in mice treated with bioluminescent tumors.Intutitive processing of quantitative radiance data and raw mouse images is supported through a user friendly GUI interface.PDF tutorial for GUI is hosted on google drive:https://drive.google.com/file/d/1Q7HhJTXOGI4TXo2OvoolGBY3IscC_FG0/view?usp=sharingTo use this package:If anaconda is not installed, follow installation instructions here:https://docs.anaconda.com/anaconda/install/Start terminal, type in and enter:conda activateNow install radianceQuantifier via PyPi by typing the following line in the terminal:pip install radianceQuantifierIn this anaconda environment, type:python3 -m radianceQuantifierto start the program
Package: radiant
Brython-RadiantA Brython Framework for Web Apps development.Radiant is aBrythonframework for the quick development of web apps with pure Python/Brython syntax so there is no need to care about (if you don’t want) HTML, CSS, or Javascript. Run overTornadoservers and include support toWebsockets,Python ScriptsandMDC.InstalationpipinstallradiantUsageBare minimum# Radiant modulesfromradiant.serverimportRadiantAPI# Brython modulesfrombrowserimportdocument,html# This modules are faked after `radiant` inport# Main class inheriting RadiantAPIclassBareMinimum(RadiantAPI):# Constructordef__init__(self,*args,**kwargs):super().__init__(*args,**kwargs)#-----------------------------------------------------------# Brython code (finally)document.select_one('body')<=html.H1('Hello World')## ...all your brython code#-----------------------------------------------------------# Run serverif__name__=='__main__':BareMinimum()Extra options# Radiant modulesfromradiant.serverimportRadiantAPI,RadiantServer# import RadiantServer for advanced optionsfrombrowserimportdocument,html# Main class inheriting RadiantAPIclassBareMinimum(RadiantAPI):def__init__(self,*args,**kwargs):""""""super().__init__(*args,**kwargs)#-----------------------------------------------------------# Brython codedocument.select_one('body')<=html.H1('Hello World')## ...all your brython code#-----------------------------------------------------------if__name__=='__main__':# Advance optionsRadiantServer('BareMinimum',host='localhost',port=5000,brython_version='3.9.1',debug_level=0,)How to worksThis is basically a set of scripts that allows the same file run fromPythonandBrython, when is running underPythonaTornadoserver is created and configure the local path for serving static files, and a custom HTML template is configured in runtime to import the same script, this time underBrython, is very simple.
Package: radiant-compiler
Radiant-CompilerPull the image with the environ forpython-for-androidthat includes theAndroid NDKand theSDKto compile Python applications into APKs installer:dockerpullyeisondev/radiant:compilerThen install the Python pacakge to use thep4acommand:pipinstallradiant-compilerNowp4ais replaced bydocker_p4adocker_p4aapk--archarm64-v8aSoftware versions included in the imageARGNDK_VERSION=r23bSDK_VERSION=8512546_latestJAVA_VERSION=jdk17-openjdkNDKAPI=27ANDROIDAPI=27
Package: radiant-framework
Radiant FrameworkA Brython Framework for Web Apps development.OverviewRadiant Framework is a novel web framework designed to leverage the capabilities ofBrython, a browser-based Python implementation. This innovative approach allows developers to write web applications entirely in Python, bypassing the conventional requirements of HTML, CSS, or JavaScript for frontend development.Key FeaturesPython-Centric DevelopmentUnified Language Usage: Write your entire web application using Python, ensuring a consistent and streamlined coding experience.Brython Integration: Utilizes Brython for executing Python code in the browser, enabling a seamless transition of server-side code to client-side execution.Server and Browser CompatibilityDual Environment Execution: Radiant enables the same application code to run both on the server and in the browser, maximizing code reusability and efficiency.Tornado Web Server: On the server-side, Radiant harnesses theTornadoweb server to deploy applications, known for its scalability and non-blocking network I/O capabilities.Resource ManagementStatic File Handling: Simplifies the management of static files (images, stylesheets, etc.), by setting up a local path for their serving, facilitating their inclusion in the application.Runtime ConfigurationDynamic HTML Templates: Radiant offers a custom HTML template system, configurable at runtime, to dynamically import server-side scripts into the browser environment.BenefitsStreamlined Development Process: By unifying the development language and environment, Radiant significantly reduces the complexity and learning curve associated with traditional web development.Code Efficiency: Eliminates the need for writing separate frontend and backend code, leading to more maintainable and concise codebases.Focus on Quality: Developers can concentrate on crafting high-quality Python code, without the distractions of dealing with various web technologies.InstallationTo install Radiant, you can usepip, the Python package manager. Simply run the following command in your terminal:pipinstallradiant-frameworkBare minimumTo help you get started with Radiant, let's walk through a bare minimum example. This example will demonstrate how to create a simple web page that displays some text. We'll utilize the Radiant framework to craft the page and run it on a local server. This is an excellent way to familiarize yourself with how Radiant functions and to begin exploring its capabilities.PrerequisitesBefore proceeding, ensure that you have Radiant installed on your system. If you haven't installed Radiant yet, please refer to theInstallationsection for guidance.Creating a Simple Web PageThe following script illustrates a basic application using Radiant. This script will set up a simple web page displaying a heading.fromradiant.framework.serverimportRadiantAPIfrombrowserimportdocument,htmlclassBareMinimum(RadiantAPI):def__init__(self,*args,**kwargs):super().__init__(*args,**kwargs)document.select_one('body')<=html.H1('Radiant-Framework')if__name__=='__main__':BareMinimum()