Saravanan666/pypi-org huggingface dataset:
Package: consentdb
Consent databaseHolds consent information. Does this person give permission for her or his data to be used?Free software: MIT licenseDocumentation:https://consentdb.readthedocs.io.FeaturesModels consent per patient via sqlalchemyWeb API via flaskDocumented json reponses (openAPI 3.0)CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-04-29)First release on PyPI.
Package: consentiumthings
ConsentiumThings Python API DocumentationOverviewConsentiumThings is a Python API designed to facilitate sending and receiving data to and from Consentium Cloud. It provides an easy-to-use interface for developers to interact with Consentium Cloud services programmatically.InstallationYou can install ConsentiumThings via pip:pipinstallconsentiumthingsUsageImporting ConsentiumThingsfromconsentiumthingsimportconsentiumthingsInitializing ConsentiumThingsTo initialize ConsentiumThings, you need to provide your board key.ct=consentiumthings("board_key")Sending DataTo send data to Consentium Cloud, use thebegin_send()method followed bysend_data().ct.begin_send("send_key")ct.send_data([1,2,3,4],['info1','info2','info3'])Receiving DataTo receive data from Consentium Cloud, use thebegin_receive()method followed byreceive_data().ct.begin_receive("receive_key",recent=False)print(ct.receive_data())Methodsconsentiumthings(board_key)Parameters:board_key(str): The key associated with the board.begin_send(send_key)Parameters:send_key(str): The key associated with the send operation.send_data(data, info_list)Parameters:data(list): The data to be sent.info_list(list): List of information associated with each data item.begin_receive(receive_key, recent=False)Parameters:receive_key(str): The key associated with the receive operation.recent(bool, optional): If True, only the most recent data will be received. Default is False.receive_data()Returns:List of received data.Examplefromconsentiumthingsimportconsentiumthings# Initialize ConsentiumThingsct=consentiumthings("board_key")# Send datact.begin_send("send_key")ct.send_data([1,2,3,4],['info1','info2','info3'])# Receive datact.begin_receive("receive_key",recent=False)print(ct.receive_data())SupportFor any issues or questions regarding ConsentiumThings Python API, please contactconsentium.inc@gmail.com.LicenseThis software is licensed under the MIT License. See the LICENSE file for details.
Package: consent-log
Django Consent LogSome django views which log actions taken on the frontend, these return an emtpy HTML page and are intended
to be called from an ajax function on the frontend. No frontent functions are provided but there are many cookie
and other consent banner action projects on npmjs.com which can be use the build the frontend component.The  timestamp, user agent string, referrer are stored along with a boolean flag for consent /reject
status. Additionally the request body is also stored so the frontend can send supplemental data to store.An expiry framework is included which provides a mechanism for deletion of records older than
a certain, the rentenion period can be set in the settings.py file. The expiry framework
also has a mechanism to limit it runs to a maximum frequency.Anonymized IP address storage is planned but not yet implemented.This provides the views and the management logs for
the purposeSetupAdd:'consent_log'toINSTALLED_APPSin settings.py and also a set an integer
valueCONSENT_LOG_DAYS_EXPIRYto settings.py to configure
the length of time that consent record live for.You must also set the boolean valueCONSENT_LOG_AUTO_EXPIRE, this
setting is treated as a booleand and if true expire_consent_log() is call
on every request to the confirm or reject views.If you use theexpire_consent_log()model function (such as via the auto
expire setting above), or expireconset management command you can set a
maximum frequency at which the the expire run will happen.CONSENT_LOG_EXPIRY_MIN_PERIOD = 7 # Only run expiry once a week maxmum.you must set ths variable if you use these entrypoints.To UseAdd something like the following to your projects urls.py..path("consent_log/", include("consent_log.urls"))This add the modules endpoints to your defined urls, our urls are
reversable and namedconsent-log:confirmand ‘consent-log:reject`` within
django url namespace so can be reference as those insire your django templates.You will need to write or import your own frontend integration
to send the actions to record to this module.
Package: conservation-scores-dataset
Pipeline to automatically retrieve and preprocess conservation scoresInstalling the packageAs for any python package, simply run:pipinstallconservation_scores_datasetUsage examplesThe following two usage examples will show both how to run the pipeline and how to retrieve the already pre-computed values stored within this GitHub repository.Running the pipeline to retrieve the dataIf you want to run the pipeline yourself, after taking note that some preprocessed data are already available within this repository, consider that the downloaded file will require a total size of ADDSIZE.After having installed the package, just run the following to retrieve all data relative to the FANTOM5 and ROADMAP datasets for enhancers and promoters:fromconservation_scores_datasetimportretrieve_allretrieve_all()It will display some loading bars showing you what the pipeline is doing at a given time, such as the following ones:Based on the main loop provided in the retrieve all file, other similar automati retrieval pipelines for other BED files can be trivially built.
Package: conservator
Framework for client-side load-balancing for inter-process
communication between cloud services.It is inspired in large part by Netflix’sRibbonfor java.How to UseIn its most basic form, you can create aballast.Servicewith a static list of servers:>>>importballast>>>my_service=ballast.Service(['127.0.0.1','127.0.0.2'])Now, just use it as you would use therequestspackage:>>>response=my_service.get('/v1/path/to/resource')<Response[200]>NOTE:at this point in time, only the basic api features from therequestspackage are supported.For advanced usage, checkout thedocs
Package: consider
What is this?Consider is a parser for the ThinkGear protocol used by NeuroSky devices (MindSet, BrainBand and others).Consider connects to ThinkGear Connector (“ThinkGear Connector.exe” for Windows) to get packets, so it can be used on Windows or Mac OS X easily.See also thinkgear (https://github.com/groner/pythinkgear) that parses it more directly (not use ThinkGear Connector).Getting startedConsider can be installed with pip or easy_install:pip install considerFirstly, start ThinkGear Connector. In the case of Windows, execute “ThinkGear Connector.exe” that is included in SDK, specify a COM port and push “Start” button.Create Consider object, and you can get a ThinkGear packet:>>> from consider import Consider
>>> con = Consider()
>>> packet = con.get_packet()
>>> print(packet.attention)
16
>>> print(packet.high_beta)
1.90662092336e-06
>>> print(packet)
{'high_beta': 1.9066209233642439e-06, 'low_beta': 7.4952608883904759e-06, 'attention': 16, 'low_gamma': 4.8011397666414268e-06, 'delta': 7.1328349804389291e-06, 'meditation': 87, 'poor_signal': 0, 'high_alpha': 4.27748489073565e-07, 'high_gamma': 0.00022232596529647708, 'length': 32, 'theta': 2.0189656879665563e-06, 'low_alpha': 9.1102498345208005e-07}You can get a packet generator for streaming:>>> from itertools import islice
>>> for p in islice(con.packet_generator(), 10):
...     # get 10 packets
...     print(p.meditation, p.high_alpha, p.low_alpha)

    (96, 7.493017619708553e-05, 5.1031893235631287e-05)
    (99, 0.00021125955390743911, 2.6392026484245434e-06)
    (98, 5.571280894400843e-07, 5.3168583690421656e-05)
    (91, 2.5947028348127787e-07, 1.6530602806597017e-06)
    (79, 3.5061493690591305e-05, 1.1179225793966907e-06)
    (64, 1.420417902409099e-06, 2.2484807686851127e-06)
    (48, 0.00025273021310567856, 2.7587668682826916e-07)
    (32, 3.7225916003080783e-06, 3.6896562960464507e-07)
    (17, 0.00020242333994247019, 1.2374764992273413e-05)
    (7, 0.00019503712246660143, 2.0322062482591718e-05)LicenseConsider is licensed under the MIT Licence. See LICENSE for more details.
Package: consign
ConsignConsign is a simple library to validate and store data in different sources.>>> import consign
>>> import requests
>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
>>> r.status_code
200
>>> consign.text(r.text, './local_file.txt')
>>> consign.json(r.json(), './local_file.json')
>>> consign.blob(r.json(), './cloud_file.json', provider='azure', connection_string=private_keys, container=container_name)Consign allows you to validate and store data extremely easily, whether in a
local file or in a cloud storage.
Package: consistency-models
Consistency ModelsThis repository contains the codebase forConsistency Models, implemented using PyTorch for conducting large-scale experiments on ImageNet-64, LSUN Bedroom-256, and LSUN Cat-256. We have based our repository onopenai/guided-diffusion, which was initially released under the MIT license. Our modifications have enabled support for consistency distillation, consistency training, as well as several sampling and editing algorithms discussed in the paper.The repository for CIFAR-10 experiments is in JAX and will be released separately.Pre-trained modelsWe have released checkpoints for the main models in the paper. Before using these models, please review the correspondingmodel cardto understand the intended use and limitations of these models.Here are the download links for each model checkpoint:EDM on ImageNet-64:edm_imagenet64_ema.ptCD on ImageNet-64 with l2 metric:cd_imagenet64_l2.ptCD on ImageNet-64 with LPIPS metric:cd_imagenet64_lpips.ptCT on ImageNet-64:ct_imagenet64.ptEDM on LSUN Bedroom-256:edm_bedroom256_ema.ptCD on LSUN Bedroom-256 with l2 metric:cd_bedroom256_l2.ptCD on LSUN Bedroom-256 with LPIPS metric:cd_bedroom256_lpips.ptCT on LSUN Bedroom-256:ct_bedroom256.ptEDM on LSUN Cat-256:edm_cat256_ema.ptCD on LSUN Cat-256 with l2 metric:cd_cat256_l2.ptCD on LSUN Cat-256 with LPIPS metric:cd_cat256_lpips.ptCT on LSUN Cat-256:ct_cat256.ptDependenciesTo install all packages in this codebase along with their dependencies, runpipinstall-e.Model training and samplingWe provide examples of EDM training, consistency distillation, consistency training, single-step generation, and multistep generation incm/scripts/launch.sh.EvaluationsTo compare different generative models, we use FID, Precision, Recall, and Inception Score. These metrics can all be calculated using batches of samples stored in.npz(numpy) files. One can evaluate samples withcm/evaluations/evaluator.pyin the same way as described inopenai/guided-diffusion, with reference dataset batches provided therein.CitationIf you find this method and/or code useful, please consider citing@article{song2023consistency,title={Consistency Models},author={Song, Yang and Dhariwal, Prafulla and Chen, Mark and Sutskever, Ilya},journal={arXiv preprint arXiv:2303.01469},year={2023},}
Package: consistent
consisTent is a full blows testing framework for prompts. The goal of consisTent is to create reproducible tests for LLM based applications regardless of the FM used.InstallationpipinstallconsistentConceptsconsisTent comes with 2 types of validators (testers)syntactic validatorsThis type of validators is used to do static assertions of the LLM output. for example validating if the output is in a certain JSON format and assert the schema.
You can also use syntactic validators to assert something is a valid piece of code (JS or Python are supported at the moment)Syntactic validators are used to assert the FORM of the responseexampleconsisTent.JsValidator().validate('console.log("Im a JS program!")')consisTent.PyValidator().validate('print("Im a python program!")')consisTent.JsonValidator().validate('{"question": "is this a valid JSON?"}')syntactic validatorsThis type of validators is used to assert the quality of the response with more "soft" parameters for example, check if something is factually correct, check for hallucinations, check for labels like "funny"/"interesting" etc... another type of semantic validator is the semantic consistency validator where you provide a seed of validated input and a threshold, and the test will assert the semantic distance of the new output from the seed cluster.Semantic validators are used to assert the CONTENT of the responseexampleimportconsisTentseed=["the cat sat on the mat","the feline layed on the carpet",]consisTent.ConsistencyValidator(seed_size=2,consistency_threshold=0.5,).validate(seed=seed,model_output="the dog sat on the mat",)Label TestOPENAI_KEY="XXXXXXXXXXXXXXX"consisTent.LabelsValidator(openai_key=OPENAI_KEY).validate(labels=["funny","short","about rabbits",],model_output="What do you call a rabbit that tells jokes? A funny bunny!",)facts validationOPENAI_KEY="XXXXXXXXXXXXXXX"consisTent.FactsValidator(openai_key=OPENAI_KEY).validate(facts=["this car weighs 1000KG"],model_output="I can lift this car",)
Package: consistent_hash
consistent-hashImplements consistent hashing that can be used when the number of server nodes can increase or decrease.The algorithm that is used for consistent hashing is the same as libketama <https://github.com/RJ/ketama>UsageIt’s so easy to use^_^:from consistent_hash import ConsistentHash

# You can construct consistent hash with the below three ways
con_hash = ConsistentHash({'192.168.0.101:11212':1, '192.168.0.102:11212':2, '192.168.0.103:11212':1})
# Or
con_hash = ConsistentHash(['192.168.0.101:11212', '192.168.0.102:11212', '192.168.0.103:11212']))
# Or
con_hash = ConsistentHash('192.168.0.101:11212')

# Add servers to hash ring
con_hash.add_nodes({'192.168.0.104:11212':1})
# Get a server via the key of object
server = con_hash.get_node('my_key')
# Delete the server from hash ring, you don't need to indicate weights
con_hash.del_nodes(['192.168.0.102:11212', '192.168.0.104:11212'])Unit testFirstly, install nose which extends unittest to make testing easier:pip install noseThen, run tests:# Option -s any stdout output will be printed immediately
# and -v be more verbose
nosetests -s -vMore information about nose <https://nose.readthedocs.org/en/latest/>
Package: consistentsamplerpkg
consistent_samplerRoutinesamplerfor providing 'consistent sampling' --- sampling that is
consistent across subsets.  Consistent sampling works by associating a random number with
each element; the desired sample is found by taking the subset of the desired sample size
containing those elements with the smallest associated random numbers.The sampling isconsistentsince it consistently favors elements with small associated
random numbers; if two sets S and T have substantial overlap, then their samples of a given
size will also have substantial overlap (for the same random seed).This routine is intended for use in election audits,
where the objects being sampled are ballots, but this procedure
is for general use.  For a similar election audit sampling method,
see Stark's election audit tools:https://www.stat.berkeley.edu/~stark/Vote/auditTools.htmThis routine takes as input a finite collection of distinct object ids, a random seed, and
some other parameters.  The sampling may be "with replacement" or "without replacement".
One of the additional parameters to the routine is "take" -- the size of the desired
sample.It provides as output a "sampling order" --- an ordered list of object ids that determine
the sample.  For sampling without replacement, the output can not be longer than the input, as no
object may appear in the sample more than once.  For sampling with replacement, the output
may be infinite in length, as an object may appear in the sample an arbitrarily large
(even infinite) number of times.  The output ofsampleris therefore always a python
generator, capable of producing an infinitely long stream of output object ids.As a small example of sampling without replacement:g = sampler(['A-1', 'A-2', 'A-3', 'B-1', 'B-2', 'B-3'], 
            with_replacement=False, take=4, seed=314159, output='id')yields a generator g whose output can be printed:print(list(id for id in g))which produces:['B-2', 'B-3', 'A-3', 'A-2']Consistent sampling is not a new idea, see for examplehttps://arxiv.org/abs/1612.01041and the references to consistent sampling therein.The routine here may (or may not) be novel in that it extends consistent
sampling to sampling with replacement: when an item is sampled and then replaced
in the set of items being sampled, it is given a new random number drawn uniformly
from the set of numbers in (0, 1) larger than its previous associated number.
To implement this efficiently and portably, we represent a number in (0, 1) as
a variable-length decimal string of the form '0.dddddd...' .For our applications, one big advantage of consistent sampling is the following.
If each county collects cast ballots separately, then they can order their own ballots
for sampling and interpretation independently of what other counties are doing.  An overall
sample can be constructed from the individual county samples.Further documentation and examples are in the code.
Package: consmodel
Welcome to consmodel library 👋!!! Warning: the library is active and the functionalities are being added on weekly basis, some functionalities will also change !!!The library aims to provide a simple way to create individual consumer loads and generation.The library is a centralised modelling tool that implements the following consumption/generation consumptions:pure consumption model,solar plant model,heat pump model,electric vehicle modelling,possibly other models...The main idea of the library is to be able to easily create consumption or generation power consumption profiles.The schema of the library is as follows:🏠HomepageInstallpip3installconsmodelUsagePV modelfromconsmodelimportPVimportpandasaspdimportnumpyasnpimportmatplotlib.pyplotasplt# create a simple PV modelpv=PV(lat=46.155768,lon=14.304951,alt=400,index=1,name="test",freq="15min",)timeseries=pv.simulate(pv_size=14.,year=2022,model="ineichen",consider_cloud_cover=True)# plot the resultstimeseries.plot()plt.show()BS modelfromconsmodelimportBSimportpandasaspdimportnumpyasnpimportmatplotlib.pyplotasplt# create a simple PV modeltest_consumption=[0.,-3.,-2.,8.,7.,6.,7.,8.,5.,4.,-2.]test_consumption_df=pd.DataFrame({"p":test_consumption},index=pd.date_range("2020-01-01 06:00:00",periods=11,freq="15min"))bs=BS(lat=46.155768,lon=14.304951,alt=400,index=1,st_type="10kWh_5kW",freq="15min",)timeseries=batt.simulate(control_type="installed_power",p_kw=test_consumption_df)# plot the resultstimeseries.plot()plt.show()Consumer modelfromconsmodelimportConsumerModelimportpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltcons=ConsumerModel(lat=46.155768,lon=14.304951,alt=400,index=1,name="ConsumerModel_default",tz="Europe/Ljubljana",use_utc=False,freq="15min",)timeseries=cons.simulate(has_generic_consumption=False,has_pv=True,has_heatpump=True,has_ev=False,has_battery=True,start=pd.to_datetime("2020-01-01 06:15:00"),end=pd.to_datetime("2020-01-01 06:00:00")+pd.Timedelta("1d"),pv_size=14.,wanted_temp=20.,hp_st_type="Outdoor Air / Water (regulated)",bs_st_type="10kWh_5kW",control_type="production_saving")timeseries.plot()plt.show()Author👤Blaž DobravecWebsite:https://github.com/blazdobGithub:@blazdobLinkedIn:@https://www.linkedin.com/in/blaz-dobravec/Colaborated:Matej Oblak:@MatejGitOblakBine Flajnik:@Bine-f🤝 ContributingContributions, issues and feature requests are welcome!Feel free to checkissues page.Show your supportGive a ⭐️ if this project helped you!
Package: console-alarm
Console AlarmConsole alarmis a small alarm function for your console.ImportantFor now just tested on ubuntu.DependenciesPyGameandNumPyfor creating the alarm sound.UsageConsole alarmis usable with one or two numeric argumentsOne argument:If there is only one argument it is interpreted as minutes. The alarm will act
as a pomodoro that rings after the set minutes.e.g.console_alarm 5Two arguments:With two arguments, you will set an alarm clock for a specified time.
If you set 14 09 as arguments, the alarm will start at 14:09.e.g.console_alarm 14 09DocumentationFor more information take a look at the documentation atwww.ruerob.com.Nice to knowOn Ubuntu you can put this task into background with 'ctrl+z' and then run 'bg'
Get it to the foreground again with fg
Package: consoleAppMath
# consoleAppA simple console App in python using docopt**Installation**`$ git clone https://github.com/kimobrian/consoleApp.git``$ cd consoleApp`Create and activate a virtual environment.```$ virtualenv venv$ source venv/bin/activate```Install `docopt``$ pip install docopt`Run the application with either of the two commands:```$ python app.py --interactive$ python app.py -i```**Commands**```add <numberA> <numberB> e.g add 5 59sum <numberA> <numberB> e.g sum 23 56div <numberA> <numberB> e.g div 85 5multi <numberA> <numberB> e.g multi 21 40```
Package: consoleargs
Argument parser for humansThis library implements simple argument parser,
based on function signature and docstring messagesUsageUsage example:>>> from consoleargs import command
>>> @command
>>> def main(destination, name=None, verbose=0):
>>>   """
>>>    :param destination: Where to look
>>>    :param name: Whot to search
>>>    :param verbose: How much to talk
>>>   """
>>>   print destination, name, verbose
Package: consolebar
ConsoleBarPython Module which creates stunning progress bars for showing progress of loops and iterables in python.InstallationSimply using PyPi:pip install consolebarUsageSimply run the following python code:fromconsolebarimportConsoleBarforiteminConsoleBar(object'''(list(), tuple(), dict(), range(), iterable, etc.)''',optional_params):#Do your stuffThats it!Parametersloop_to_execute (Required):Python loop parameter (list(), dictionary(), tuple(), str(), range(), etc.) i.e. iterable object for which progress bar is shown.prefix (Optional):A string which is shown before the progress bar to describe the progress bar (Default: "Progress:").suffix (Optional):A string which is shown after the progress bar to describe the progress percentage shown after the progress bar (Default: "Complete").length (Optional):Length of the progress bar in charecters. Can be adjusted according to one's console charecter width (Default: 50).Highly useful when you want to run huge loops but don't want to just see the blinking cursor of the console while it is executing.
Package: console-chat-dsima
Console Chat DsimaThis project is a test task for Digital Design. It's written without using any third-party library.InstallationIt works only on Linux operating systems.To install it runpip install console-chat-dsimaUsageTo start a serverrunpython -m chat-server;input server address (127.0.0.1, as an example).To chatrunpython -m chat-client;input server address;input your name;to send a message input it's text and addressee;to exit the chat inputexit.To stop the server pressControl+C.ExamplesServer$ python3 -m chat-server
Input server address: 127.0.0.1
^CTraceback (most recent call last): <...>
KeyboardInterruptClient 1$ python3 -m chat-client
Input server address: 127.0.0.1
Input your name: Ivan
To send a message input its text and addressee.
Input "exit" to exit.
Hey, how do you do?
Maria
Maria received your message.
Maria: I'm fine.
Save my soul!
God
God did not receive your message.
exitClient 2$ python3 -m chat-client
Input server address: 127.0.0.1
Input your name: Maria
To send a message input its text and addressee.
Input "exit" to exit.
Ivan: Hey, how do you do?
I'm fine.                     
Ivan
Ivan received your message.
exit