Saravanan666/pypi-org huggingface dataset:
Package: gabber
GabberSimple tool to pull posts and users from Gab.UsageUsage: gabber [OPTIONS] COMMAND [ARGS]...

Options:
  --user TEXT        Username to gab.com account. Required to pull posts. If
                     unspecified, uses GAB_USER environment variable.
  --password TEXT    Password to gab.com account. Required to pull posts. If
                     unspecified, uses GAB_PASS environment variable.
  --threads INTEGER  Number of threads to use in the pull (if unspecified,
                     defaults to 25).
  --help             Show this message and exit.

Commands:
  groups  Pull groups and (optionally) their posts from Gab.
  users   Pull users and (optionally) posts from Gab.usersUsage: gabber users [OPTIONS]

  Pull users and (optionally) posts from Gab.

Options:
  --users-file TEXT              Where to output the user file to.
  --posts-file TEXT              Where to output the posts file to.
  --first INTEGER                The first user ID to pull.
  --last INTEGER                 The last user ID to pull.
  --created-after FROMISOFORMAT  Only pull posts created on or after the
                                 specified date, e.g. 2021-10-02 (defaults to
                                 none).
  --posts / --no-posts           Pull posts (WIP; defaults to no posts).
  --replies / --no-replies       Include replies when pulling posts (defaults
                                 to no replies)
  --help                         Show this message and exit.groupsUsage: gabber groups [OPTIONS]

  Pull groups and (optionally) their posts from Gab. Can pull at most 250
  pages of posts per group (5000 posts).

Options:
  --groups-file TEXT    Where to output the groups file to.
  --posts-file TEXT     Where to output the posts file to.
  --first INTEGER       The first group ID to pull.
  --last INTEGER        The last group ID to pull.
  --depth INTEGER       How many pages of posts to retrieve.
  --posts / --no-posts  Pull posts.
  --help                Show this message and exit.followersandfollowingUsage: gabber [followers|following] [OPTIONS]

  Experimental feature: pull followers from a Gab account / pull list of accounts that a Gab account follows.

Options:
  --id INTEGER                User id from which to pull followers.
  --[followers|following]-file-path TEXT  Where to output the followers file to
  --help                      Show this message and exit.Environment VariablesHTTPS_PROXY— route all traffic through this HTTPS proxy (highly recommended given Gab's rate limiting)Note: if you have a pre-existingHTTP_PROXYenvironment variable, this may be picked up by Python's requests library and produce errors.GAB_USER— the (optional) username to authenticate as with GabGAB_PASS— the (optional) password to use while authenticating with GabDevelopmentTo run Gabber in a development environment, you'll needPoetry. Install the dependencies by runningpoetry install, and then you're all set to work on Gabber locally.To access the CLI, runpoetry run gabber.
Package: gabbi
GabbiRelease NotesGabbi is a tool for running HTTP tests where requests and responses
are represented in a declarative YAML-based form. The simplest test
looks like this:tests:
- name: A test
  GET: /api/resources/idSee thedocsfor more details on the many features and formats for
setting request headers and bodies and evaluating responses.Gabbi is tested with Python 3.7, 3.8, 3.9, 3.10, 3.11, 3.12 and pypy3.Tests can be run usingunitteststyle test runners,pytestor from the command line with agabbi-runscript.There is agabbi-demorepository which provides a tutorial via
its commit history. The demo builds a simple API using gabbi to
facilitate test driven development.PurposeGabbi works to bridge the gap between human readable YAML files that
represent HTTP requests and expected responses and the obscured realm of
Python-based, object-oriented unit tests in the style of the unittest
module and its derivatives.Each YAML file represents an ordered list of HTTP requests along with
the expected responses. This allows a single file to represent a
process in the API being tested. For example:Create a resource.Retrieve a resource.Delete a resource.Retrieve a resource again to confirm it is gone.At the same time it is still possible to ask gabbi to run just one
request. If it is in a sequence of tests, those tests prior to it in
the YAML file will be run (in order). In any single process any test
will only be run once. Concurrency is handled such that one file
runs in one process.These features mean that it is possible to create tests that are
useful for both humans (as tools for improving and developing APIs)
and automated CI systems.Testing and Developing GabbiTo get started, after cloning therepository, you should install the
development dependencies:$ pip install -r requirements-dev.txtIf you prefer to keep things isolated you can create a virtual
environment:$ virtualenv gabbi-venv
$ . gabbi-venv/bin/activate
$ pip install -r requirements-dev.txtGabbi is set up to be developed and tested usingtox(installed viarequirements-dev.txt). To run the built-in tests (the YAML files
are in the directoriesgabbi/tests/gabbits_*and loaded by the filegabbi/test_*.py), you calltox:tox -epep8,py37If you have the dependencies installed (or a warmed up
virtualenv) you can run the tests by hand and exit on the first
failure:python -m subunit.run discover -f gabbi | subunit2pyunitTesting can be limited to individual modules by specifying them
after the tox invocation:tox -epep8,py37 -- test_driver test_handlersIf you wish to avoid running tests that connect to internet hosts,
setGABBI_SKIP_NETWORKtoTrue.
Package: gabbi-tempest
Gabbi-tempest is aTempestpluginthat enables testing the APIs of running
OpenStack services, integrated with tempest but without needing to write
Python. Instead the YAMLformatprovided bygabbiis used to write and
evaluate HTTP requests and responses.Tests are placed in YAML files in one or more directories. Those directories
are added to aGABBI_TEMPEST_PATHenvironment variable. When that variable
is passed into a tempest test runner that is aware of the gabbi plugin, the
files on that path will be used to create tempests tests.The test harness sets a series of enviornment variables that can be used in
the YAML to reach the available services. The available variables may be
extended in two ways:Adding them to the environment that calls tempest if the values are
known.Setting them in a subclass of the plugin if the values need to
be calculated from what tempest knows.For each service in the service catalog there are<SERVICE_TYPE>_SERVICEand<SERVICE_TYPE>_BASEvariables
(e.g.,PLACEMENT_SERVICEandPLACEMENT_BASE). A usefulSERVICE_TOKEN,IMAGE_REF,FLAVOR_REFandFLAVOR_REF_ALTare also available.Read the docs athttps://gabbi-tempest.readthedocs.io/
Package: gabby
<a href="https://codeclimate.com/github/luanguimaraesla/gabby/maintainability"><img src="https://api.codeclimate.com/v1/badges/dc94cbf3854b542d3862/maintainability" /></a><a href="https://travis-ci.org/luanguimaraesla/gabby"><img src="https://travis-ci.org/luanguimaraesla/gabby.svg?branch=master" /></a><a href="https://badge.fury.io/py/gabby"><img src="https://badge.fury.io/py/gabby.svg" /></a><a href="https://codecov.io/gh/codecov/example-python"><img src="https://codecov.io/gh/luanguimaraesla/gabby/branch/master/graph/badge.svg" /></a># Python GabbyA simple controller for MQTT and MQTT-SN pipelines using Mosquitto and RSMB## InstallingYou can install the package through pip```bashpip install gabby```## ExamplesBefore run examples, please initialize the Mosquitto or RSMB server.#### Receiving messages```pythonfrom gabby.gabby import Gabby, Topicfrom gabby.controller import Controllerclass PrinterGabby(Gabby):def transform(self, message):print(f'ARRIVED! Data: {message.data}')return []if __name__ == "__main__":controller = Controller()topic_A = Topic('queue/a', 'i')topic_B = Topic('queue/b', 'i')printer_gabby = PrinterGabby([topic_A], [topic_B])controller.add_gabby(printer_gabby)controller.run()```#### Transmitting messages```pythonfrom gabby.gabby import Gabby, Topicfrom gabby.message import Messageif __name__ == "__main__":topic_A = Topic('queue/a', 'i')topic_B = Topic('queue/b', 'i')g = Gabby([topic_B], [topic_A])data = (1,)g.send(Message(data, g.output_topics))```#### Using UDP broker```pythonfrom gabby.gabby import Gabby, Topicfrom gabby.controller import Controllerclass PrinterGabby(Gabby):def transform(self, message):print(f'ARRIVED! Data: {message.data}')return []if __name__ == "__main__":controller = Controller()topic_A = Topic('queue/a', 'i', 'udp')topic_B = Topic('queue/b', 'i', 'udp')printer_gabby = PrinterGabby([topic_A], [topic_B], transmission='udp')controller.add_gabby(printer_gabby)controller.run()```#### Using both UDP and TCP topicsYou can use both TCP and UDP brokers```pythonimport loggingfrom gabby import Gabby, Topic, Controllerclass LoggerGabby(Gabby):def transform(self, message):logging.debug(f"ARRIVED! Data: {message.data}")def setup_logging(level):"""Setup logging level"""logging.basicConfig(format='%(levelname)s: %(message)s',level=getattr(logging, level.upper()))if __name__ == "__main__":setup_logging('debug')controller = Controller()topic_A = Topic('qa', 'i', 'udp')topic_F = Topic('qb', 'i', 'udp')topic_B = Topic('queue/1', 'i', 'tcp')topic_C = Topic('queue/a', 'i', 'tcp')topic_D = Topic('queue/b', 'i', 'tcp')topic_E = Topic('queue/c', 'i', 'tcp')logger_gabby = LoggerGabby([topic_A, topic_F, topic_B, topic_C, topic_D, topic_E],transmission=['tcp', 'udp'])controller.add_gabby(logger_gabby)controller.run()```
Package: gabes
IntroductionGarbled Circuits allow two distrusting parties
to compute a joint function while keeping their inputs private. More precisely,
it allows Alice with inputxand Bob with inputyto compute a functionf(x, y)without Alice ever knowingyand without Bob knowingx. The way
it does so is by first translatingfto a boolean circuit from which it will
cleverly obfuscate orgarblethe circuit to allow the computation offwhile keeping the inputs private.The classical example is that of two millionaires who wish to find out who is
richer without revealing their wealth. In that case,fbecomes the “>” (greater
than) function, andxandyare their wealth.Gabesimplements garbled circuits in Python. The application runs as a command
line interface but the functions required to run garbled circuits can be used without
the command line (see gabes).InstallationAt the command line either via pip:$ pip install gabesOr, if you have virtualenvwrapper installed:$ mkvirtualenv gabes
$ pip install gabesUsageEach party will run their own instance of the program on their computer as a CLI app.
The garbler will provide the IP and port number to establish the connection with the
evaluator.NoteMake sure to open the port when connecting between two different networks.Garbler’s Side:gabes -g -grr3 -c Desktop/my-circuit.circuit -a localhost:5000Evaluator’s Side:gabes -e -grr3 -a localhost:5000Flagsusage: gabes [-h] [-g] [-e] [-b bits] [-i identifier [identifier ...]]
                   [-c file] -a ip:port [-cl] [-pp] [-grr3] [-free] [-grr2]
                   [-fle] [-half]

Program to garble and evaluate a circuit.

optional arguments:
  -h, --help            show this help message and exit
  -g, --garbler         Set this flag to become the garbler
  -e, --evaluator       Set this flag to become the evaluator
  -b bits, --bits bits  Include your private input bitstring to the circuit
                        (e.g. 001011)
  -i identifier [identifier ...], --identifiers identifier [identifier ...]
                        Indicate which input wires you supply to the circuit
                        (e.g. -i A C D)
  -c file, --circuit file
                        Path of the file representing the circuit. Only the
                        garbler needs to supply the file
  -a ip:port, --address ip:port
                        IP address followed by the port number
  -cl, --classical      Set this flag for classical garbled circuits
  -pp, --point-and-permute
                        Set this flag to include point-and-permute
  -grr3, --grr3         Set this flag for GRR3 garbled circuits
  -free, --free-xor     Set this flag for free-xor garbled circuits
  -fle, --flexor        Set this flag for flexor garbled circuits
  -half, --half-gates   Set this flag for half gates garbled circuitsDocumentationAll the documentation can be found inhttps://gabes.readthedocs.io/en/latest/
Package: gabes-firstpackage
gabes_firstpackagegabes_firstpackage is my first attempt at creating a package. I chose to use my first Multilayer Perceptron code for this package, whose objective was to help me learn OOP and to improve my understading of neural networks, the backpropagation algorithm and its equations.This also my first time using a repository (and therefore GitHub). Long story short: this project is not supposed to be anything fancy, it's just a personal project so I can hone my Python skills an refresh some knowledge.InstallationUse the package managerpipto install gabes_firstpackage.pipinstallgabes-firstpackageSucess!As of 30/12/2023 20:49 UTC-3 I've sucessfully distributed a working version of gabes_firstpackage. I used a local host on Google Colab to try it out on some small datasets I had. You may find my results on the following links:https://colab.research.google.com/drive/1NOMsq0moVhtMWS-GGYQInNpougVmDplP?usp=sharinghttps://colab.research.google.com/drive/1qCntDWHbeOd_MaeNS36MUYEs4SXMZhLo?usp=sharingLike I've previously said, this was just a personal project so that I could improve some of my skills, so I took a simplistic approach for most things.I don't intend to make any changes to this project for a long while, but I do hope some other student stumbles upon it and makes good use of it.
Package: gabi
ContentsgabiUsageMutt integrationPassword for Google acccountFuture plansChanges0.2.0 (2010-09-26)0.1.0 (2010-09-12)gabigabi stands for Google Address Book Importer but it can also means Google Address Book Immediately or Google Address Book for paranoid IdiotsUsagegabi’s algorithm is quite simple:Download contacts from Google ContactsSave them into a file in json formatPerform a queryOutput the query resultsStep 1 is smart enough to only download those contacts that have changed since the last invocation.For step 3 you should pass some query args to the command line. The query is performed as the OR of all query args. A query arg can be a simple string or a string with a ‘:’ character. If a single string is used that text is matched in every attribute of a contact except for the id. If a ‘:’ is found in the query arg, it is used to split the attribute name and the value to match. In this case only that attribute will be searched.Right now only step 4 is flexible enough to allow the user to choose from different output formats. Supported formats include simple, json and mutt. In the future other steps are expected to be more configurable.Mutt integrationJust edit your .muttrc file and add a line like this:set query_command = "/usr/bin/gabi --user=your_google_email --password=your_password --store=/home/user/contacts.json --output-type=mutt '%s'"Now you will be able to search your Google Contacts from Mutt.Password for Google acccountThere are 3 different ways to input the password that is used to authenticate your Google account:Use the –password command line optionFetch the password from the GNOME keyringEnter the password interactivelyThese options are tried in that order. The second one, GNOME keyring, is only used if you have that software installed in your system and its daemon is running. If no password for gabi is found in the GNOME keyring, it will ask the user to enter one and it will save it on the GNOME keyring.Future plansremove deleted contacts from Google Contacts in the store file.add a store backend for mongo dbif no query args are given output all contactsChanges0.2.0 (2010-09-26)Add support for GNOME keyring. Now the password can be fetched from there.0.1.0 (2010-09-12)Initial release
Package: gabia-sms-Django
Python 2 & 3 compatibleSource code:https://github.com/athenaslab/gabia-sms-DjangoDistribution:https://pypi.python.org/pypi/gabia-sms-DjangoMaintainer:https://github.com/hwshim0810InstallationYou can install the library directly from pypi using pip:$pipinstallgabia-sms-DjangoEdit your settings.py file:GABIA_SMS_SETTINGS={'SENDER':'YOUR NUMBER','API_ID':'YOUR API ID,'API_KEY':'YOUR API KEY'}DependenciesPython 2.7 or 3.4+Django 1.11+QuickstartSend sms message to use shortcut functionimportgabia_smstry:# Send single SMSgabia_sms.send(message='message',receiver='will receive phone number')exceptSMSModuleException:print('SMS send failure')SMS Types: [‘sms’, ‘lms’, ‘multi_sms’, ‘multi_lms’]Send function returning Tuple(Unique key, Result code)More usageimportgabia_smstry:# Reserve single SMSgabia_sms.send(message='message',receiver='will receive phone number',scheduled_time='2018-02-02 22:22:22')# if not assign scheduled_time, send immediatelygabia_sms.send(message='message',receiver='will receive phone number')# Send multiple SMSgabia_sms.send(message='message',receiver=['phone number','...'])gabia_sms.send(message='message',receiver=('phone number','...'))# Reserve multiple SMSgabia_sms.send(message='message',receiver=['phone number','...'],scheduled_time='2018-02-02 22:22:22')# Cancel reservationgabia_sms.cancel_reservation('Unique key','SMS type')# Request result codegabia_sms.get_send_result('Unique key')exceptSMSModuleException:print('SMS send failure')Advanced usageInherit SMS class, override post_sent_sms / before_send_smsimportgabia_smsclassAdvancedSMSModule(gabia_sms.GabiaSMS):defpost_sms_sent(self,param,*args,**kwargs):# ... Do what you needdefbefore_send_sms(self,param,*args,**kwargs):# ... Do what you needAdvancedSMSModule.send(message='message',receiver='will receive phone number')or Use SingletonClassimportgabia_smsclassAdvancedSMSModule(gabia_sms.SingletonGabiaSMS):# ...passContributorsSeehttps://github.com/hwshim0810/gabia-sms-Django/graphs/contributors
Package: gabia-sms-python
===========================Gabia SMS module for Python===========================Python 2 & 3 compatible- Source code: `<https://github.com/taylor-kang/gabia-sms-python>`_- Distribution: `<https://pypi.org/project/gabia-sms-python>`_- Maintainer: `<https://github.com/taylor-kang>`_Installation------------You can install the library directly from pypi using pip:.. code-block:: shell$ pip install gabia-sms-pythonDependencies------------- Python 2.7 or 3.4+Quickstart----------Before api usage, set your Gabia API-ID,API-KEY, SENDER value.. code-block:: pythonimport gabia_sms# Set Gabia-sms configuregabia_sms.configure(api_id='API_ID', api_key='API_KEY', sender='SENDER')Send sms message to use shortcut function.. code-block:: pythonimport gabia_smstry:# Send single SMSgabia_sms.send(message='message', receiver='will receive phone number')except SMSModuleException:print('SMS send failure')- SMS Types: ['sms', 'lms', 'multi_sms', 'multi_lms']- Send function returning Tuple(Unique key, Result code)More usage----------.. code-block:: pythonimport gabia_smstry:# Reserve single SMSgabia_sms.send(message='message',receiver='will receive phone number',scheduled_time='2018-02-02 22:22:22')# if not assign scheduled_time, send immediatelygabia_sms.send(message='message',receiver='will receive phone number')# Send multiple SMSgabia_sms.send(message='message', receiver=['phone number', '...'])gabia_sms.send(message='message', receiver=('phone number', '...'))# Reserve multiple SMSgabia_sms.send(message='message',receiver=['phone number', '...'],scheduled_time='2018-02-02 22:22:22')# Cancel reservationgabia_sms.cancel_reservation('Unique key', 'SMS type')# Request result codegabia_sms.get_send_result('Unique key')except SMSModuleException:print('SMS send failure')Advanced usage--------------Inherit SMS class, override post_sent_sms / before_send_sms.. code-block:: pythonimport gabia_smsclass AdvancedSMSModule(gabia_sms.GabiaSMS):def post_sms_sent(self, param, *args, **kwargs):# ... Do what you needdef before_send_sms(self, param, *args, **kwargs):# ... Do what you needAdvancedSMSModule.send(message='message', receiver='will receive phone number')or Use SingletonClass.. code-block:: pythonimport gabia_smsclass AdvancedSMSModule(gabia_sms.SingletonGabiaSMS):# ...passAcknowledgements--------------Thanks `https://github.com/athenaslab/gabia-sms-Django` for gabia-sms-Django version
Package: gabid
gabid packageThis package implements the Gaussian and Binomial Distributions providing the following capabilities:Compute the mean and standard deviation given a file with all the samplesCompute the pdfAllows to add two of the kindFor Gaussian distribution only:Plot histogramPlot histogram pdfFor Binomial distribution only:Plot barPlot bar pdfInstallationTo start using this package just type:pip install gabidFilesThis package provides three classes:Distribution,GaussianandBinomial.
TheDistributionclass is only used to read all the values from a txt file and convert them into a list.
BothGaussianandBinomialinherit from this class.Quick startSee Gaussian example:gaussian = Gaussian(25, 2)
gaussian.read_data_file('numbers.txt') # numbers.txt is a txt with all the samples
gaussian.calculate_mean() # to recompute mean according to the data in the txt
gaussian.calculate_stdev() # to recompute standard deviation according to the data in the txt
gaussian.pdf(25) # to compute the pdf of a valueReferencesUsed resourcesGaussian DistributionBinomial DistributionContributorsSara GarciLicense© Copyright 2019 by Sara Garci. All rights reserved.
Package: gabi-distribution
# gabi-distribution packageThis package contains classes for Gaussian and Binomial distribution# What is Gaussian distribution?In probability theory, a normal (or Gaussian or Gauss or Laplace–Gauss) distribution is a type of continuous probability distribution for a real-valued random variable.# What is Binomial distribution?In probability theory and statistics, the binomial distribution with parameters n and p is the discrete probability distribution of the number of successes in a sequence of n independent experiments, each asking a yes–no question, and each with its own boolean-valued outcome: success/yes/true/one (with probability p) or failure/no/false/zero (with probability q = 1 − p). A single success/failure experiment is also called a Bernoulli trial or Bernoulli experiment and a sequence of outcomes is called a Bernoulli process; for a single trial, i.e., n = 1, the binomial distribution is a Bernoulli distribution. The binomial distribution is the basis for the popular binomial test of statistical significance.# FilesGeneraldistribution.py - This is the base class for the Gaussian and Binomial dostribution class
Gaussiandistribution.py - This is the class for Gaussian distribution
Binomialdistribution.py - This is the class for Binomial distribution# InstallationType the following command into your terminalpip install gabi_distribution