Saravanan666/pypi-org huggingface dataset:
Package: refit
RefitSimple remote server configuration and deployment, using asyncio.Read the Docs.Why Refit?As a die hard Ansible user for many years, I started looking for something slightly different.Because of Docker, most of my deployments have become simpler. It usually involves uploading some files (e.g.docker-compose.yaml), and running some shell commands (e.g.docker-compose up). As a result, I don't need most of the modules that Ansible provides.One thing I originally found great about Ansible was being able to configure it purely in YAML. This is nice when you're getting started. As your projects get larger though, you yearn for the control that code gives you. For example, rather than having to learn the particular syntax for performing 'for loops' in YAML, just do it naturally in Python.Ansible is still great - but if you want to work in Python rather than YAML, give Refit a go.Isn't it all about serverless nowadays?Configuring servers is still a daily reality for many people, and will continue to be so for the foreseeable future. Need websockets? Can't stand the slow start up times of serverless? Want to avoid vendor lock in? Using VMs still makes a lot of sense.Why asyncio?Asyncio is a new approach to concurrency which was added in Python 3. It uses an event loop, rather than threads or processes. A typical use case is building a proxy, or a higher throughput web application.It turns out that asyncio also works great for remote server configuration too. The reason is, your typical server config work flow looks a bit like this:MACHINE A          MACHINE B
   ---------          ---------
(TASK A1, TASK A2)     TASK B1
       |                  |
    TASK A3               |
                       TASK B2Using async, we can fire off tasks A1, A2, and B1 simultaneously. Once complete, we then fire off task A3, and finally task B2. Refit will orchestrate the tasks so the servers are provisioned as quickly as possible.It also means you can use all the exciting new asyncio libraries within your code.PropsBuilt on top of the great work done inasyncssh.
Package: refit-loader
REFIT LoaderThis project usesDask Dataframesto ease and fasten the process of loading all the data of REFIT and provides functionalities to transform and manipulate the REFIT dataset for statistical analysis purpose.About REFIT datasetAn electrical load measurements dataset of United Kingdom households from a two-year longitudinal study. Sci Data 4, 160122 (2017).Murray, D., Stankovic, L. & Stankovic, V.For more detail information, visit the following links:http://dx.doi.org/10.1038/sdata.2016.122https://rdcu.be/cMD9FDependenciesEnsure that the following dependencies are satisfied either in your current environment- python>=3.9.2
  - numpy>=1.20.3
  - pandas>=1.2.4
  - dask>=2021.06.2
  - scikit-learn>=1.1.2or create a new environment using 'environment.yml'conda create env --file=environment.yml
conda activate refit_loader_envGetting StartedInstall the refit-loader in your current target environmentpip install refit-loaderDownloadthe refit dataset. Import the REFIT_Loader and pass the data path to the refit object.from refit_loader.data_loader import REFIT_Loader
refit = REFIT_Loader(data_path='')Fetch the list of available appliances for selected houses.refit.get_appliance_names(house=2)Load data for selected appliance (all houses)kettle = refit.get_appliance_data(appliance='Kettle')(OR) Load data for selected house (all appliances).house2 = refit.get_house_data(house=2)(OR) Load data for sselected appliance and elected houses.kettle = refit.get_appliance_data(appliance="Kettle", houses=[1,2,3])Take the reference from Refit_Analyzer to see how Refit_Loader can be accessed and how it's utilities can be used.Reference Repository:Refit Analyzer= REFIT analyzer is more like a user guide that uses REFIT Loader as a submodule and demonstrates how it can be used and how it can be useful with its utilities.Repo Structure:This repository follows the below structure format:|
|── data_loader.py
|
├── metadata
|  └── REFIT_README.txt
|
├── modules
|  └── active_durations.py
|  └── parser.py
|  └── validations.py
|  └── normalisation.py
|
├── environment.yml
|
├── readme.md
|DownloadsThe REFIT Smart Home dataset is a publicly available dataset of Smart Home data.Dataset -https://pureportal.strath.ac.uk/files/52873459/Processed_Data_CSV.7zMain Page -https://pureportal.strath.ac.uk/en/datasets/refit-electrical-load-measurements-cleanedCitationMurray, D., Stankovic, L. & Stankovic, V. An electrical load measurements dataset of United Kingdom households from a two-year longitudinal study. Sci Data 4, 160122 (2017). https://doi.org/10.1038/sdata.2016.122
Package: refitt
REFITTis an autonomous machine learning system that yields optimal
observing strategies in real time to participating facilities, instruments, and astronomers. It
subscribes to LSST data brokers and forecasts supernova light curves. Recommendations are created
for individual subscribers based on availability and capability.DocumentationREFITT is not a meant as a public tool, yet it’s construction and administration are made available
for transparency and understanding. It’s open REST API is documented, making it possible to automate
the use of REFITT without needing to interact with the web interface.An overview of the system, configuration and deployment instructions, and other documentation can be
found online atrefitt.readthedocs.io.ContributingWe welcome feedback as well as contributions to the code and documentation. If you are here to
report a bug, please create anIssuehere ongithub.com/refitt/refitt.
Before opening aPull Request, we ask that you read ourcontributingguidelines.AcknowledgementsReferences, citations, and acknowledgments will be updated here.
Package: refkeys
Refkeys: A secure way for sharing secret (key).Author & Developer:Ravin KumarThis repository contains a tool for secret-sharing among two parties.For example, lets say two parties A and B want to share a secret_key, such that only if they both agree than only they should be able to get the secret.
Our software generates 3 individual keys, one for each party, and one for the mediator. When these keys are combined then only the secret_key can be revealed.Advantage of our system:Even though the same secret is shared among G1={a,b,c} and G2={x,y,z}. The beauty of refkeys is that, even if some member of a group tries to contact other group members to generate the secret key, it can not be generated.Only when all parties of G1 agrees than only they can generate the secret_key.Demonstration for generating individual keys:importrefkeyskey=refkeys.get_keys("secure_key_passed_here")person1_key=key[0]person2_key=key[1]mediator_key=key[2]## note: person1_key,person2_key,mediator_key are of type-list.Demonstration for generating individual filekeys:importrefkeysrefkeys.get_keyfiles("secure_key_passed_here","person1_name","person2_name","mediator_name",path="./")## note: names should be distinct, and mediator name is not mandatory.Demonstration for generating secret key using individual keys:importrefkeys....secret_key=refkeys.combine_keys(person1_key,person2_key,mediator_key)## note: person1_key,person2_key,mediator_key are of type-list.Demonstration for generating secret key using filekeys:importrefkeys....secret_key=refkeys.combine_keyfiles(person1_key,person2_key,mediator_key)## note: names should be distinct, and mediator name is not mandatory.Installation using pip:pipinstallrefkeysCopyright(c)2019RavinKumarWebsite:https://mr-ravin.github.ioPermissionisherebygranted,freeofcharge,toanypersonobtainingacopyofthissoftwareandassociateddocumentationfiles(the“Software”),todealintheSoftwarewithoutrestriction,includingwithoutlimitationtherightstouse,copy,modify,merge,publish,distribute,sublicense,and/orsellcopiesoftheSoftware,andtopermitpersonstowhomtheSoftwareisfurnishedtodoso,subjecttothefollowingconditions:TheabovecopyrightnoticeandthispermissionnoticeshallbeincludedinallcopiesorsubstantialportionsoftheSoftware.THESOFTWAREISPROVIDED“ASIS”,WITHOUTWARRANTYOFANYKIND,EXPRESSORIMPLIED,INCLUDINGBUTNOTLIMITEDTOTHEWARRANTIESOFMERCHANTABILITY,FITNESSFORAPARTICULARPURPOSEANDNONINFRINGEMENT.INNOEVENTSHALLTHEAUTHORSORCOPYRIGHTHOLDERSBELIABLEFORANYCLAIM,DAMAGESOROTHERLIABILITY,WHETHERINANACTIONOFCONTRACT,TORTOROTHERWISE,ARISINGFROM,OUTOFORINCONNECTIONWITHTHESOFTWAREORTHEUSEOROTHERDEALINGSINTHESOFTWARE.
Package: refl1d
Refl1D is a program for analyzing 1D reflectometry measurements made with
X-ray and neutron beamlines.  The 1-D models give the depth profile for
material scattering density composed of a mixture of flat and continuously
varying freeform layers. With polarized neutron measurements, scientists
can study the sub-surface structure of magnetic samples. The architecture
supports the addition of specialized layer types such as models for the
density distribution of polymer brushes, and volume space modeling for
proteins in bio-membranes. We provide a number of these models as well as
supporting user defined layer types for both structural and magnetic
scattering densities.Fitting is provided by Bumps, a bayesian uncertainty analysis program.  In
addition to the usual uncertain estimated from the covariance at the best
fit location, Bumps includes a Markov chain Monte Carlo analysis code which
more completely describes the uncertain and correlations between parameters.
Fitting is done in parallel, either using python multiprocessing on a
multicore machine, or using MPI for running on a cluster.Documentation is available athttps://refl1d.readthedocs.io. SeeCHANGES.rstfor details on recent changes.Use “pip install refl1d wxpython” to install in your python environment.For the windows application, follow the installation instructions on thelatest releasepage.  (For the latest bleeding-edge build, see theunstable release)Submit requests and pull requests to the projectgit pages
Package: reflectdb
NOTE: Update ReflectDB to>0.1.8as there is a major bug in itReflectA low level RAM free Database SystemExamplefromtqdmimporttqdm# Install TQDM for testsfromreflect.databaseimportDatabase,Identity,String,Valuedb=Database("data.refldb","data.refldc")db.create_all()classNames(db.Model):name=String()email=String()identity=Identity()test_amount=10000foriintqdm(range(test_amount)):x=db.refine(Names,name="Owie",email="Ow1e3@protonmail.com")y=db.dumps(x)db.publish(y)withtqdm(total=test_amount)ast:db.query()t.update(test_amount)
Package: reflection
Reflection is a wrapper aroundtkinterwith support for Python 2 and 3.It aims to be a more intuitive way of creating graphical interfaces, while keeping the ability to modify widgets in any way you want.
Although still in alpha, things are looking good for development.
The next versions will bring event handling, new widgets and window manager interactions.FeaturesSupport for the following widgets:Application(tkinter.Tk)Window(tkinter.Toplevel)Frame(tkinter.Frame)Text(tkinter.Label)Image(tkinter.Label)Button(tkinter.Button)Entry(tkinter.Entry)Support for more than 30 image types (requires thePILlibrary)Custom styles to personalize interfacesCompletely clutter-free!InstallationGetting started is easy. Just download the latest version from PyPi.org:pipinstallreflectionNote:You may need to replacepipwithpip3if you plan on using reflection in Python 3.HelpReflection is still in alpha, so bugs are to be expected. The semantics of the library may change a great deal over time.If you’ve found a bug or have a question, please open an issue on GitHubhere.
Package: reflectionist
reflectionistA simple CLI app that helps you to track your reflections during your day.Why?Being capable of reflecting helps to understand stressful situations.Having a different perspective on what happened facilitates to take actions on how to behave to avoid the same feeling again reducing your stress levels and enabling personal growth!Reflection questionsThe following questions were extracted from my experience at Hyper Island, during the master's in Digital Management.1. What happened that affected me?
2. How did I feel then and now?
3. What did I learn about myself?InstallationInstall reflectionist with pippipinstallreflectionistFeaturesInit environment:reflectionist initAdd reflection:reflectionist createList reflections:reflectionist listDescribe specific reflection:reflectionist describeContributingContributions are always welcome! Just open a new issue that I will check it ASAP.
Package: reflective
ReflectiveReflective provides a plethora of ways to access and manipulate structured data.Notice!This project is in early-stage development so the API may change aggressively,
and some features are not currently present.Branch StatusBranchCodeQLBuilddev0.2.0Table of ContentsBranch StatusTL;DRInstallationProject DocumentationProject InformationContributingConfigurationLibrary DevelopmentLibrary TestingSecurity PolicySupport PolicyCode of ConductLicenseDonateTL;DRWith Reflective, you can access and update composite data structures in many ways:fromreflectiveimportReflectivedata={"app":{"name":"Appy McAppface","description":"The $r{/app/name} app is a great!","version":"1.2.3","tags":["production","release","v$r{/app/version}"],}}r=Reflective(data)print(r.app.name)# Appy McAppfaceprint(r.app['description'])# The Appy McAppface app is a great!print(r.app('version'))# 1.2.3print(r.app.tags)# ['production', 'release', 'v1.2.3']print(r.app.tags().raw)# ['production', 'release', 'v$r{/app/version}']print(r.app.tags[2])# v1.2.3print(r.app.tags[2]().raw)# v$r{/app/version}For a much better explanation of all the features you see here, please see
theFeature Documentation.InstallationNotice! This requires Python 3.8+To install the Python package, run the following command in your Python environment:python3-mpipinstallreflectiveThe PyPi package is automatically built and published to the PyPi repository for each release. If you want to install
a release from the source, run the following commands in your terminal:python3-mpipinstall--upgradegit+
gitclonehttps://github.com/AzorianSolutions/reflective.gitcdreflective
gitcheckouttags/v<release-version>-brelease/<release-version>
python3-mpipinstall.Project DocumentationProject InformationFor information about the project such as feature planning, the roadmap, and milestones, then please see theProject Informationsection of the
wiki.ContributingIf you're interested in participating in the project design discussions, or you want to actively submit work to the
project then you should check out theContribution Guide!ConfigurationFor information about all the ways this library can be configured and what each setting does, please visit theConfiguration Guidesection of the wiki.Library DevelopmentFor information about how the library is designed and actually works, please visit theDevelopment Guidesection of the wiki.Library TestingFor information on how to create and execute automated library tests, please visit theTesting Guidesection of the wiki.Security PolicyPlease see ourSecurity Policy.Support PolicyPlease see ourSupport Policy.Looking to chat with someone? Join ourDiscord Server.Code of ConductPlease see ourCode of Conduct.LicenseThis project is released under the MIT license. For additional information,see the full license.DonateLike my work?Want to sponsor me?Please visit my organization'ssponsorship page.
Package: reflective-listening
Reflective ListeningThis API generates reflective listening statements by way of paraphrasing. Reflective listening is one of the four
techniques used in Motivational Interviewing, a counselling method commonly used to promote behavioural change.Therapists use reflective listening to convey understanding of one's issue, demonstrating empathy,
allowing the chatbot to engage the user better, build trust, and foster motivation to change in the person.ExampleThis API allows conversational agents to reflectively listen to the user they're talking to. For example:User: "Today is a bad day, I'm feeling lonely"Chatbot's reflective listening response: "I understand, seems you are feeling lonely on a bad day."QuickstartInstallationpipinstallreflective-listeningHow to usefromreflective_listeningimportReflectiveListeningreflector=ReflectiveListening()print(reflector.get_response("Today is a bad day, I'm feeling lonely"))Output:"I understand, seems like you are feeling lonely on a bad day."
Package: reflectivipy
Reflectivipy is an API inspired byReflectivity in Pharo. Reflectivity allows you to deal
with partial behavioral reflection in Python by letting you installMetaLinkdirectly on method AST nodes. Moreover, Reflectivity provides object-centric
capabilities and let you install a modified behavior on a dedicated object.Let see how to install a link on a method AST towards a meta-object:importreflectivipy# We define a new meta-object that will act as a logger# each time a dedicated AST node will be "visited/executed"classMetaLogger(object):deflog_me(self):print("I'm here")# Here is the class we will instrumentclassExampleClass(object):deffoo(self):print('Executing foo')# We create a link ('control' is 'before' by default)link=reflectivipy.MetaLink(MetaLogger(),selector='log_me',control='before')# We get the method AST we want to instrumentrf_ast=reflectivipy.reflective_ast_for_method(ExampleClass,'foo')# We select the node that we want to install the link on# Here we selected the "print 'Executing foo'" AST node.node=rf_ast.body[0].body[0]# We install the link on the nodereflectivipy.link(link,node)a=ExampleClass()a.foo()# When we don't need it anymore, we remove itprint('Uninstall Metalink')link.uninstall()a.foo()# Produces:## I'm here# Executing foo# Uninstall Metalink# Executing fooThis small code example uses the two main Reflectivipy concepts:the meta-object definition, i.e: the object that will own the behavior to addtheMetaLinkin itself which link the meta-object to the AST node that
must be modified.The MetaLinklinkis used to install a new behaviorbeforethe code
associated  to the AST node on which it will be installed. The method AST is
then gathered using thereflective_ast_for_methodfunction. The desired AST
node is gathered (here it’s theprintnode). Finally, the node and the
meta-behavior are linked together using thelinkfunction. Once the new
meta-behavior is not required anymore, theuninstallmethod of the created
link is called. This call uninstall the link from every node it could be
installed on.On top of that, meta-behavior can be installed for a dedicated instance instead
of a class. To do that, it’s just a matter of asking for thereflective_ast_for_methodof the instance instead of the one from the class.
The code remains then exactly the same.InstallationCurrently, Reflectivity is now onpypi, so you can install it usingpip. It is recommanded to install it in the virtualenv.$pipinstallreflectivipyQuick StartContributorsSteven Costiou (@StevenCostiou), main author of ReflectivipyVincent Aranega (@aranega)
Package: reflectrpc
0.7.6 (2016-09-14)Support for typed arraysAutocompletion of type and function names in rpcshBugfixes for command-line programsAutoreconnect in case of failing connections in command-line programs0.7.5 (2016-08-17)Fixes rpcsh crash with Python 2.70.7.4 (2016-08-11)RPC functions run by the Twisted server can now return Deferreds to implement concurrent RPC servicesLinux sys info example service0.7.3 (2016-07-24)Support for UNIX domain socketsNew rpcgencode tool to generate client code for a running RPC service0.7.2 (2016-07-01)BugfixesAutomatic generation of service documentation with the new rpcdoc toolHTTP Basic Auth for client and Twisted serverMechanism for passing context to RPC functions (rpcinfo)0.7.1 (2016-05-12)Adds missing package dependencies0.7.0 (2016-05-11)First release
Package: reflex-core
reflex-corereflexReflex enforces security best practices in cloud environments through event-driven automation. Get started by visitingour documentation.reflex-corePackage for the core Reflex classes. You can use these classes to easily create Reflex rules to secure your cloud environment (currently only supports AWS).You'll also want to familiarize yourself with the other parts of Reflex:reflex-cli, a CLI for creating and managing your Reflex rules and environment.reflex-engine, Terraform modules for deploying required Reflex rule infrastructure.reflex documentation, general documentation about deploying reflex.InstallationYou can installreflex-coreusingpip.pip install reflex-coreUsageTo utilizereflex-core, simply import the rule class you want to utilize and implement the required methods.from reflex_core import AWSRule

class MyRule(AWSRule):
    def extract_event_data(event):
        # Logic for extracting required event info

    def resource_compliant():
        # Logic for determining if the resource configuration is compliant

    # etcFor examples, browse provided rules onReflexive Security's GitHub.LicenseReflex is made available under the MPL 2.0 license. For more information view theLICENSE
Package: reflex-debounce-input
reflex-debounce-inputA wrapper around the genericreact-debounce-inputcomponent for the
python-based full stackreflexframework.Since all events in reflex are processed on the server-side, a client-side input debounce makes the app feel much less
sluggish when working will fully controlled text inputs.Exampleimportreflexasrxfromreflex_debounce_inputimportdebounce_inputclassState(rx.State):query:str=""app=rx.App(state=State)@app.add_pagedefindex():returnrx.center(rx.hstack(debounce_input(rx.input(placeholder="Query",value=State.query,on_change=State.set_query,),),rx.text(State.query),))app.compile()reflex initreflex runAlso work with textarea, simply passrx.text_areaas the child. Seelarger examplein the repo.UsageIncludereflex-debounce-inputin your projectrequirements.txt.Include a specific version ofreact-debounce-inputinrxconfig.py.config=rx.Config(...,frontend_packages=["react-debounce-input@3.3.0",],)Wrapreflex_debounce_input.debounce_inputaround the component
to debounce (typically arx.inputorrx.text_area).PropsSee documentation forreact-debounce-input.min_length: int = 0Minimal length of text to start notify, if value becomes shorter then minLength (after removing some characters), there will be a notification with empty value ''.debounce_timeout: int = 100Notification debounce timeout in ms. If set to -1, disables automatic notification completely. Notification will only happen by pressing Enter then.force_notify_by_enter: bool = TrueNotification of current value will be sent immediately by hitting Enter key. Enabled by-default. Notification value follows the same rule as with debounced notification, so if Length is less, then minLength - empty value '' will be sent back.NOTE: if onKeyDown callback prop was present, it will be still invoked transparently.force_notify_on_blur: bool = TrueSame asforce_notify_by_enter, but notification will be sent when focus leaves the input field.Changelogv0.3 - 2023-05-19Support pynecone >= 0.1.30 (pynecone.varchanged topynecone.vars)v0.2 - 2023-04-24import reflex_debounce_inputautomatically addsreact-debounce-inputtoConfig.frontend_packagesfix example in README, missing commaimprove test assertions when exporting example projectv0.1 - 2023-04-21Initial Release