Saravanan666/pypi-org huggingface dataset:
Package: rapidsms-healthcare
rapidsms-healthcare is a reusable Django application for managing healthcare provider
and patient records for building RapidSMS applications. The goal is to create a common
API for storing and accessing these records and have configurable storage backends
for the data itself. For instance on site might store data using a SQL database via
the Django ORM while another might store the data in OpenMRS. Additional Django/RapidSMS
applications can use this API to store and retrive data without knowning how it will be stored.Dependenciesrapidsms-appointments currently runs on Python 2.6 and 2.7 and requires the following
Python packages:Django >= 1.4RapidSMS >= 0.11.0DocumentationDocumentation on using rapidsms-healthcare is available onRead The Docs.Running the TestsWith all of the dependancies installed, you can quickly run the tests with via:python setup.py testor:python runtests.pyTo test rapidsms-healthcare in multiple supported environments you can make use
of thetoxconfiguration.:# You must have tox installed
pip install tox
# Build default set of environments
tox
# Build a single environment
tox -e py26-1.4.XLicenserapidsms-healthcare is released under the BSD License. See theLICENSEfile for more details.ContributingIf you think you’ve found a bug or are interested in contributing to this project
check outrapidsms-healthcare on Github.
A full contributing guide can be found in theonline documentation.Development sponsored byCaktus Consulting Group, LLC.
Package: rapidsms-multimodem
MultiModem iSMSbackend for theRapidSMSproject.Licenserapidsms-multimodem is released under the BSD License. See theLICENSEfile
for more details.SettingsThe following parameters are required:sendsms_url,sendsms_user,sendsms_pass,modem_port, andserver_slug:"multimodem-1": {
    "ENGINE": "rapidsms_multimodem.outgoing.MultiModemBackend",
    "sendsms_url": "http://192.168.170.200:81/sendmsg",
    "sendsms_user": "admin",
    "sendsms_pass": "admin",
    "modem_port": 1,
    "server_slug": "isms-lebanon",
},Single port modems only have 1 port, but it should still be specified.Theserver_slugparameter serves 2 purposes. It uniquely identifies the iSMS server, so that
RapidSMS doesn’t get confused by 2 different servers having the same port number (since those are
restricted to be integers from 1 to 8). It’s also used to create the RapidSMS URL that the iSMS
server will send messages to. Yoururls.pyshould look something like this:urlpatterns = [
    url(r"^backend/multimodem/(?P<server_slug>[\w_-]+)/$",
        receive_multimodem_message,
        name='multimodem-backend'),
]With the 2 code examples above, your iSMS server should POST messages tohttp://your-rapidsms-server.example.com/backend/multimodem/isms-lebanon/.ContributingIf you think you’ve found a bug or are interested in contributing to this
project check outrapidsms-multimodem on Github.Development byCaktus Consulting Group.
Package: rapidsms-multitenancy
rapidsms-multitenancy allows you to host multiple RapidSMS instances in one cohesive project.WarningThis is pre-alpha software. The code is subject to change without notice and there is no
documentation. It is probably not ready for production use.DescriptionWhy would you want to use rapidsms-multitenancy? It was built for a situation where a large
organization has operations in multiple countries. It’s desirable for each country to have its own
RapidSMS instance so that users can easily communicate with that local backend. On the other hand,
it’s a pain to install RapidSMS in each location as you’d have to do each installation separately,
keep each installation updated, and have user accounts duplicated over installations.rapidsms-multitenancy allows you to have one central RapidSMS installation with multiple tenants.
Each tenant is associated with one RapidSMS backend with the aim of keeping each tenant
separate. Superusers of the system can view multiple tenants.Running the TestsYou can run the tests with via:python setup.py testLicenserapidsms-multitenancy is released under the BSD License. See theLICENSEfile for
more details.ContributingIf you think you’ve found a bug or are interested in contributing to this
project check outrapidsms-multitenancy on Github.Development sponsored byThe International Rescue Committee.
Package: rapidsms-threadless-router
ARapidSMSrouter implementation that
removes the threading functionality from the legacy Router class.  Rather, all
inbound requests are handled via the main HTTP thread.  Backends can optionally
pass requests to a message queue for out-of-band responses.threadless_routerattempts to:Make RapidSMS backends more Django-like.  Use Django’s URL routing and views to handle inbound HTTP requests.Remove clutter and complexity of route process and threaded backends.Ease testing – no morethreadingorQueuemodules slowing down tests.Please refer to thedocumentationfor more details.Development byCaktus Consulting Group.
Package: rapidsms-twilio
Twiliobackend for theRapidSMSproject. Usespython-twilioto communicate with Twilio.FeaturesIncoming (MO) and Outgoing (MT) SMS support.Support for Twilio’sstatus callbackRequirementsPython 2.7 or Python 3.3+Django 1.7+RapidSMS v0.18.0+Future versions: We currently support Django 1.8 with no pending deprecation warnings in our 1.0
release. We expect each future point release to similarly support the next version of Django, so our
1.1 release would support Django 1.9 with no pending deprecation warnings. Support for older Django
versions may be dropped when the period of ‘mainstream support’ expires. See Django’ssupported
versionsdocumentation for those timelines.Installationrapidsms-twilio requires Django >= 1.7 and Python >= 2.7.To install from PyPi:pip install rapidsms-twilioDocumentationDocumentation on using rapidsms-twilio is available onRead The Docs.Licenserapidsms-twilio is released under the BSD License. See theLICENSEfile for
more details.ContributingIf you think you’ve found a bug or are interested in contributing to this
project check outrapidsms-twilio on Github.Development byCaktus Consulting Group.
Package: rapidsockets
RapidSockets Python SDKIntroductionThis is the official Software Development Kit for Python to interact with the RapidSockets real-time messaging platform.Installationpip install rapidsocketsQuickstartfromrapidsocketsimportRapidSocketsimporttime# initialize and open a connection to the RapidSockets Gatewayrs=RapidSockets({'key':'your multi key'})# the callback function run on a new message to channel "mytest"defmytest(packet):print(packet)# start listening for new messages on channel "mytest"rs.subscribe({'channel':'mytest','callback':mytest})# as a test, publish messages to channel "mytest" every two secondswhileTrue:rs.publish({'channel':'mytest','message':'test message'})time.sleep(2)Development specific notes# build test wheel
python3 setup.py bdist_wheel

# install test wheel
python3 -m pip install dist/rapidsockets-0.0.5-py3-none-any.whl

# upload to pypi
python3 -m twine upload dist/rapidsockets-0.0.5-py3-none-any.whl
Package: rapids-singlecell
rapids-singlecell: GPU-Accelerated Single-Cell Analysis within scverseRapids-singlecell offers enhanced single-cell data analysis as a near drop-in replacement predominantly for scanpy, while also incorporating select functionalities from squidpy and decoupler. Utilizing GPU computing with cupy and Nvidia’s RAPIDS, it emphasizes high computational efficiency. As part of the scverse ecosystem, rapids-singlecell continuously aims to maintain compatibility, adapting and growing through community collaboration.Broad GPU Optimization:Facilitates accelerated processing of large datasets, with GPU-enabled AnnData objects.Selective scverse Library Integration:Incorporates key functionalities from scanpy, with additional features from squidpy and decoupler.Easy Installation Process:Available via Conda and PyPI, with detailed setup guidelines.Accessible Documentation:Provides comprehensive guides and examples tailored for efficient application.Our commitment with rapids-singlecell is to deliver a powerful, user-centric tool that significantly enhances single-cell data analysis capabilities in bioinformatics.InstallationCondaThe easiest way to installrapids-singlecellis to use one of theyamlfile provided in thecondafolder. Theseyamlfiles install everything needed to run the example notbooks and get you started.conda env create -f conda/rsc_rapids_24.02.yml
# or
mamba env create -f conda/rsc_rapids_23.12.ymlPyPIpip install rapids-singlecellThe default installer doesn't cover RAPIDS nor cupy. Information on how to install RAPIDS & cupy can be foundhere.If you want to use RAPIDS PyPI packages, the whole library with all dependencies can be install with:pip install 'rapids-singlecell[rapids11]' --extra-index-url=https://pypi.nvidia.com #CUDA11.X
pip install 'rapids-singlecell[rapids12]' --extra-index-url=https://pypi.nvidia.com #CUDA12It is important to ensure that the CUDA environment is set up correctly so that RAPIDS and Cupy can locate the necessary libraries.DocumentationPlease have a look through thedocumentationCitationIf you use this code, please cite:Please also consider citing:rapids-single-cell-examplesandscanpyIn addition to that please cite the methods' original research articles in thescanpy documentationIf you use the accelerated decoupler functions please citedecoupler
Package: rapid-tags
rapid_tagsDescriptionpython wrapper for rapidtags.ioInstallpipinstallrapid_tags# orpip3installrapid_tagsUsagefromrapid_tagsimportRapidTagsprint(RapidTags.get_tags_cls('python programming'))# prints: ['python programming', 'python', 'python tutorial', 'learn python', 'python programming language', 'programming', 'learn python programming', 'python (programming language)', 'python programming tutorial', 'python for beginners', 'python tutorial for beginners', 'python basics', 'python course', 'python language', 'expert python programming', 'python programming course', 'python programming in hindi', 'why learn python programming', 'python full course', 'python programming for beginners', 'python crash course', 'python from scratch', 'programming tutorial']
Package: rapidTk
RapidTka wrapper for Tkinter to create objects fasterrapidTk is a simple and modifiable wrapper for the Tkinter GUI framework.As Tkinter was one of the first things i learnt while using python i though it would make a good learning excersise into complex tasks and creating packages.The goal of this project is to move away from the basic boxes of Tkinter and create some very complex objects in a simple and easy to use way while keeping the flexability of Tkinter widgets.Every object will be a collection of Tkinter widgets with additional logic and features stacked over them.e.g. autoEntry which provides a basic Entry widget with autocompletion options in a smooth and natrual way, or The WindowManager alongside moveable windows for creating and managing lots of grabbable canvas widgets.Why not use a better framework like Qt or wx ? Because Tkinter is free for both personal and commercial use. Tkinter is basic which allows high expandability on its widgets, and its simple and easy to learn.This project does not aim to be the best project in the world or even a concice package. Just a collection of objects that will work with or without eachother and make creating interfaces faster, smoother and much easier.Feel free to add your own ideas, widgets, expansions and logic to this project.Examples are in the rapidTk/examples/ directory.example of basic start. Creates a Frame, a Label, a Button and an Entry, then packs them all.root=rapidTk()##replacment for root = Tk()pp=PackProcess()## creates a process loop to pack objectsmain=pp.add(cFrame(root),side=TOP,fill=BOTH,expand=1)## creates a basic cFrame (replacemnt Frame) and adds it to the process loop to pack.pp.add(cLabel(main,text="This is a basic rapidTk Label."),side=TOP,fill=X)## creates a basic cLabel and adds it to the process loop to pack.pp.add(cButton(main,text="cButton"),side=TOP)## crates a basic cButton and adds it to the process loop to pack.myEntry=pp.add(cEntry(main,value="Some Default Text"),side=TOP,fill=X)## creates a basic cEntry and adds it to the process loop to pack.pp.pack()## runs the process loop that loops through all added widgets and packs them all with the configured options.root.mainloop()## calls mainloop on the normal Tk() object.
Package: rapidunfurl
RapidUnfurlRapidUnfurl is a Python library designed to pull and process metadata very quickly to unfurl URL contents into a JSON object that can the be used by other programs for portraying that data, similar to how link expansion works in apps like Slack.This library was originally forked from Loftie Ellis'pyunfurllibrary, which is an awesome project.  I just wanted to do some things to speed up the process, and drop away the html rendering, which I didn't need.FeaturesSupports all oEmbed providers fromhttps://oembed.com/andhttps://noembed.com/by default.Supports theautodiscoverypart of the oEmbed spec.Support forOpen Graphprotocol.Support forTwitter CardsFalls back to Meta tags and the site favicon/title if all else fails.InstallationUse the package managerpipto install pyunfurl.pipinstallrapidunfurlUsageimportrapidunfurlrapidunfurl.unfurl('https://davintaddeo.com')This will return a dict similar to the oembed spec:{"type":"website","url":"https://davintaddeo.com","title":"Davin Taddeo | DevOps Advocate","site_name":"@tdarwin","description":"Homepage of Davin Taddeo, DevOps Advocate, Senior Customer Architect for Chef","image":"https://davintaddeo.com/assets/images/round_headshot.png","card":"summary","favicon":"https://davintaddeo.com/favicon.ico"}ContributingPull requests are welcome. RapidUnfurl supports some custom integrations for sites that doesnt return any meta tags, if you want to improve the integration for a specific site you can look at the hackernews example.LicenseMIT
Package: rapidxmltojson
rapidxmltojsonrapidxmltojsonconverts xml str to json strpipinstallrapidxmltojsonExamples>>>importrapidxmltojson>>>data=rapidxmltojson.parse("""...     <root a="testa">...         <child>...             <item>text 1</item>...             <item>text 2</item>...         </child>...         <example b="testb">...             example text...         </example>...         <test-ns:example xmlns:test-ns="http://test-ns.com/">...             example text (namespaced)...         </test-ns:example>...     </root>... """)>>>importjson>>>print(json.dumps(json.loads(data),indent=4)){"root":{"@a":"testa","child":{"item":["text1","text2"]},"example":{"#text":"exampletext","@b":"testb"},"test-ns:example":{"#text":"exampletext(namespaced)","@xmlns:test-ns":"http://test-ns.com/"}}}
Package: rapidyaml
Rapid YAMLOr ryml, for short. ryml is a C++ library to parse and emit YAML,
and do it fast, on everything from x64 to bare-metal chips without
operating system. (If you are looking to use your programs with a YAML tree
as a configuration tree with override facilities, take a look atc4conf).ryml parses both read-only and in-situ source buffers; the resulting
data nodes hold only views to sub-ranges of the source buffer. No
string copies or duplications are done, and no virtual functions are
used. The data tree is a flat index-based structure stored in a single
array. Serialization happens only at your direct request, after
parsing / before emitting. Internally, the data tree representation
stores only string views and has no knowledge of types, but of course,
every node can have a YAML type tag. ryml makes it easy and fast to
read and modify the data tree.ryml is available as a single header file, or it can be used as a
simple library with cmake -- both separately (ie
build->install->find_package()) or together with your project (ie withadd_subdirectory()). (See below for examples).ryml can use custom global and per-tree memory allocators and error
handler callbacks, and is exception-agnostic. ryml provides a default
implementation for the allocator (usingstd::malloc()) and error
handlers (using usingstd::abort()is provided, but you can opt out
and provide your own memory allocation and eg, exception-throwing
callbacks.ryml does not depend on the STL, ie, it does not use any std container
as part of its data structures), but it can serialize and deserialize
these containers into the data tree, with the use of optional
headers. ryml ships withc4core, a
small C++ utilities multiplatform library.ryml is written in C++11, and compiles cleanly with:Visual Studio 2015 and laterclang++ 3.9 and laterg++ 4.8 and laterIntel Compilerryml isextensively unit-tested in Linux, Windows and
MacOS. The tests cover
x64, x86, wasm (emscripten), arm, aarch64, ppc64le and s390x
architectures, and include analysing ryml with:valgrindclang-tidyclang sanitizers:memoryaddressundefined behaviorthreadLGTM.comryml alsoruns in
bare-metal, andRISC-V
architectures. Both of
these are pending implementation of CI actions for continuous
validation, but ryml has been proven to work there.ryml isavailable in Python,
and can very easily be compiled to JavaScript through emscripten (see
below).See alsothe changelogandthe roadmap.
Package: rapl-formula
RAPL-formulaApowerAPIformula using RAPL
counters to provides power consumption information of each socket of the
monitored machine.Use RAPL data collected with thehwpc-sensorand convert it into
power consumption measures (in Watt). The power consumption measures are store
in a MongoDB database.Quick startWe detail here how to quickly start rapl-formula and connect it to a hwpc-sensor
using a mongoDB instance.For more detail see our documentationhereGet input dataYou have to launch thehwpc-sensorto
monitor sockets. The sensor must store its data in a mongoDB database. This
database must be accessible by the rapl_formula.ConfigurationYou can pass the configuration through a file or the CLI.
In both case the parameters to precises are the following :verbose(bool)stream(bool): If working with a sensor in real-timeinputoutputenable-cpu-formula(bool): Enable CPU formula', default=Trueenable-dram-formula(bool): Enable DRAM formula, default=True'cpu-rapl-ref-event(str): RAPL event used as reference for the CPU power models, default='RAPL_ENERGY_PKG''dram-rapl-ref-event(str): RAPL event used as reference for the DRAM power models, default='RAPL_ENERGY_DRAM''sensor-report-sampling-interval(int): (for stream mode) The frequency with which measurements are made
(in milliseconds)BSD 3-Clause LicenseCopyright (c) 2019, PowerAPI
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: rapnet
Rapnet Python SDK==========.. image:: https://badge.fury.io/py/rapnet.svg:target: https://badge.fury.io/py/rapnetThis is a very primary API Client Library to work with Rapnet_.----Currently it only supports `Premium JSON API`_ and `Price List API`_, DSL_ and `Upload API`_.============Installation============Via pip:.. code:: bashpip install rapnet=====Usage=====Simply Instantiate a ``RapNetAPI`` object with proper ``usernmae`` and ``password``... code:: pythonfrom rapnet import RapNetAPIrapi = RapNetAPI(username, password)Functions---------**get_price_sheet_info***Arguments: None*Returns price sheet's metadata.**get_price_sheet***Arguments: Shape[Optional]*Returns price list sheet by shape.**get_price_changes***Arguments: Shape[Optional]*Returns price changes by shape.**get_price***Arguments: params(format: JSON)[Optional]*Returns filtered price list. For filters consult `Price Doc`_.**get_diamonds_list***Arguments: params(format: JSON)[Optional]*Returns paginated, filtered diamond details. For filter parameters consult `Details Doc`_.**get_diamond***Arguments: id(format: Integer)*Return a single diamond detail by ID.**get_all_diamonds***Arguments: datafile(format: String)[Optional]*Return all diamonds details in the API. Time Consuming, Beware!**get_dsl***Arguments: datafile(format: String)[Optional]*Get Download Listing Service Data. Extra supscription needed.**upload_string***Arguments: datastring(format: String)*Upload single diamond details in a string.For formatting details consult:https://technet.rapaport.com/Info/LotUpload/Upload_HTTP.aspx**upload_csv***Arguments: uploadfile(format: String)*Upload diamonds details in a csv file.For formatting details consult:https://technet.rapaport.com/Info/LotUpload/Upload_HTTP.aspx.. _Rapnet: https://technet.rapaport.com.. _`Premium JSON API`: https://technet.rapaport.com/Info/RapLink/Format_Json.aspx.. _`Price Doc`: https://technet.rapaport.com/Info/Prices/Format_Json.aspx.. _`Details Doc`: https://technet.rapaport.com/Info/RapLink/Format_Json.aspx.. _`Price List API`: https://technet.rapaport.com/Info/Prices/Format_Json.aspx.. _DSL: https://technet.rapaport.com/Info/Dls/Integration.aspx.. _`Upload API`: https://technet.rapaport.com/Info/Landing/UploadDiamonds.aspx