Saravanan666/pypi-org huggingface dataset:
Package: fakeua
fakeuaPython3 module made as a wrapper of fake-useragent.Rationale:fake-useragent package (https://github.com/hellysmile/fake-useragent)
have an API which is brittle and too verbose for cases when you just want
predictability and the work done without unnecesary headaches.InstallationInstall with pippip3 install --user -U fakeuaUsageFakeUA can be used from the shell too.fakeua -hOr importing its functions.In [1]: import fakeua

# Update useragent DB in a json file (~/.fakeua_databrowsers.json)
In [2]: fakeua.update_useragent_db()
Out[2]: True

In [3]: fakeua.get_useragent_list()
Out[3]: 
['Mozilla/5.0 (X11; Linux i686; rv:64.0) Gecko/20100101 Firefox/64.0',
 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0',
 'Mozilla/5.0 (X11; Linux i586; rv:63.0) Gecko/20100101 Firefox/63.0',
 'Mozilla/5.0 (Windows NT 6.2; WOW64; rv:63.0) Gecko/20100101 Firefox/63.0',
 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.10; rv:62.0) Gecko/20100101 Firefox/62.0']

In [4]: fakeua.load_useragent_db()                                                 
Out[4]: ...
# It throws a dict containing the browsers scraped by fake-useragent.

In [5]: fakeua.get_random_ua()
Out[5]: 'Mozilla/5.0 (Windows NT 6.2; WOW64; rv:63.0) Gecko/20100101 Firefox/63.0'
Package: fake-ubersmith
Fake-ubersmithThis library is a web server representing a fake Übersmith where you can register api calls and response that can be used
for integration test purposes.Command line usagepip install fake-ubersmith
fake-ubersmithDocker usagedocker pull internap/fake-ubersmith:latest
docker run -d -p 8000:9131 internap/fake-ubersmithLicensefake-ubersmith is distributed underApache License Version 2.0.ContributingFeel free to raise issues and send some pull request, we'll be happy to look at them!
Package: fake_user_agent
Randomly generate a fake useragent.This project's idea is inspired byfake-useragent. I rewrote the whole codes in order to boost performance by:usingasyncioandaiohttpto improve fetching speedtaking advantage ofXpathto improve parsing speedchanging random choice algorithm to improve random choice speedSupported browsers are: chrome, edge, firefox, safari, and opera. Browser name is case insensitive. Some other possible spellings of each browser are mapped to the right one (e.g. "ie" -> "edge", "google" -> "chrome").It takes less than 2s for the first run, including fetching, parsing, and writing cache.It will take less than 0.01s starting from the second time by using cache by default.UsageAs a binaryOn your terminal, just simply enterfakeuaOther usages on terminal:# Get a useragent in debug modefakeua<browseroromit>--debug# Get a useragent without local cachingfakeua<browseroromit>--nocache# Remove cache from $HOME/.cache/fakeua folderfakeua--remove# Print the current version of the programfakeua--versionAs a libraryIn your python script, import the function. Every time you run the script, the useragent value will be different.fromfake_user_agentimportuser_agent# Not to specify a browserua=user_agent()# Specify a browser to randomly choose fromua=user_agent("chrome")# Specify not using cache, it will take < 1s to run, including fetching and parsing.ua=user_agent(use_cache=False)# If there is an async function needing a useragent in your script,# don't put `user_agent()` in your async function, put it above instead.# Remove cache in a python script.# May need `sudo python yourscript.py` for Linux.fromfake_user_agentimportrm_cacherm_cache()Installationpipinstallfake_user_agent
Package: fake-usrag-bor
Simple package with fake user agents for your requests.Installationpip install fake-usrag-borUsage1. Initialization:from fake_usrag_bor import FakeUserAgentBOR
ua = FakeUserAgentBOR()2. Some examples:#Random user agent
ua.random_user_agent()
>> Mozilla/5.0 (Windows; U; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)

#Random Google Chrome user agent
ua.random_chrome_user_agent()
>> Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.815.0 Safari/535.1

#Simple header with random user agent
ua.simple_header()
>> {'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:1.8.1.4) Gecko/20070509 Firefox/2.0.0'}

#Simple header with Opera user agent
ua.simple_header(ua.random_opera_user_agent)
>> {'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.0; Windows XP) Opera 6.04  [fr]'}NotesThis package working without Internet, it's mean, that you shouldn't make request to different sites to take some user agents.Release history0.1.41 Description fixes0.1.3 Some bug fixes for Unix systems0.1.2 Removed tested strings from main file0.1.1 Added description to README0.1 Released
Package: fake-uwsgi
A Python module that attempts to fake out the uwsgi module exposed to uWSGI
application. When testing applications outside uWSGI, for example Flask, this module
can provide some functionality of the uwsgi modulefake_uwsgiattempts to replicate APIs and variables that theuwsgimodule exposes to Python applications running in uWSGI.GitHub repo:https://github.com/digimach/fake-uwsgiDocumentation:https://github.com/digimach/fake-uwsgi/blob/master/README.rstContentsFeaturesQuickstartDevelopmentFeaturesProvides the followinguwsgi moduleAPIs:logset_logvarget_logvarworker_idworkerstotal_requestsProvides the followinguwsgi moduleglobal variables:numprocoptSets the following environment variables:INSTALL_PATHAPP_RUN_MODEQuickstartIn order to make use of Fake uWSGI everywhereimport uwsgiis used has to be
replaced with:try:
    # The following import will fail if not running in uWSGI
    import uwsgi  # pylint: disable=import-error
except ImportError:
    import fake_uwsgi as uwsgi  # pylint: disable-msg=ungrouped-importsIf your code makes use of other APIs and/or global variables that Fake uWSGI does not
expose you have two options:Monkey patch or expand thefake_uwsgimodule inside your code.Raise an feature request with this project.DevelopmentThis project usestoxto setup a development environment. Make sure you havetoxinstalled:pip install toxClone this repositoryYou can setup the development environment by running thesetup-devmake rule
from the project directory:make setup-devYou can run tests by doing:make testTo lint your code:make lintTo format your code withBlackrun:make black
Package: fake-vn-user
Welcome to Fake_VN_User!Created by NeV3RmIA python library help you to generate Fake VN User which include: name, dob, username, password, email, phone number, user agent.Website:https:// picks.workEmail:admin@picks.workInstallpip install fake_vn_userDependent libraryRandompip install randomFake_useragentpip install fake_useragentHow to useimport fake_vn_user

vnuser =  fake_vn_user.get_profile()Example Return{
   "sex":"nu",
   "first_name":"VÃ¢n Trang",
   "first_name_ra":"Van Trang",
   "last_name":"Phan",
   "last_name_ra":"Phan",
   "full_name":"Phan VÃ¢n Trang",
   "full_name_ra":"Phan Van Trang",
   "country_calling_code":"+84",
   "phone_provider":"mobiphone",
   "phone_number":"0907860597",
   "phone_activate":"+84564169581",
   "dob":"12-10-1912",
   "day":12,
   "month":10,
   "year":1912,
   "age":109,
   "username":"phanvantrang12101912",
   "password":"*sySYi7fAi}3b+",
   "email_provider":"vi.emailfake.com",
   "email_domain":"@epubea.site",
   "email":"phanvantrang12101912@epubea.site",
   "country":"Viet Nam",
   "country_2code":"VN",
   "country_3code":"VNM",
   "user_agent":"Mozilla/5.0 (Windows NT 5.1; rv:21.0) Gecko/20100101 Firefox/21.0",
   "ads":"Please check https://picks.work for more information, this product is created by NeV3RmI.",
   "version":"1.0.0"
}Logv1.0.1Add countryv 1.0.0Init project
Package: fakewsserver
Fake Websocket ServerFake in the sense that it's actually a working server (created usingwebsocketslibrary) but one that that exists briefly to allow
integration testing.Installationpip install fakewsserverUsageOne message sent, one received, everything is as expectedfromfakewsserverimportassert_communicationasyncwithassert_communication(port=12345,communication=[('hello','there')],):asyncwithwebsockets.connect('ws://localhost:12345')asclient:awaitclient.send('hello')response=awaitclient.recv()assertresponse=='there'Expected communication pattern does not matchcommunication=[('hello','there'),('general','Kenobi'),]asyncwithassert_communication(port=12345,communication=communication,):asyncwithwebsockets.connect('ws://localhost:12345')asclient:awaitclient.send('hello')response=awaitclient.recv()assertresponse=='there'awaitclient.send('admiral')awaitclient.recv()And there's a feedback what went wrong:AssertionError: Failed 2nd step:
    Expected: "general"
    Got: "admiral"
Package: fakeyou
FakeYou.pyFakeYou.pyis a python library to interact withFakeYou.comAPI easilyNote: Current Version is 1.2.0, which is a beta version for 2.0.0, anyhow, you may encounter some errors, please report tomeorftk789Contributors :Shards-7ftk789unknownZandbakInstallationuser@host $pipinstallfakeyouto install the library, you should run this commandit's a cross-platform library, you can run it anywhere, but you need python 3.6+ for better performance, and python 3.4+ at leastDocumentation !Docs over here!
Package: fakir
fakira mildly monadic module for fast fakingA deliberately minimalist library for building graphs of random number
generators with interesting dependencies, and running them to generate
plausible-looking "fake data" for a variety of domains.Pure Python with type annotations; depends only on the standardrandommodule.Let's generate some bogus data with a vaguely oil-and-gas flavor:from fakir import fixed, rng_fn, uniform, normal, choice, tupled, ifelse
from random import Random
import sys

from typing import List

def main(argv: List[str]) -> int:
    animal = choice(['Wolf', 'Eagle', 'Cheetah'])
    geo = choice(['Outcrop', 'Karst', 'Tundra'])

    formation = animal + fixed(' ') + geo

    area = normal(40, 10)
    height = uniform(10, 100)
    volume = area * height

    phase = choice(['Oil', 'Gas'])
    price = ifelse(phase == fixed('Oil'),
        uniform(30, 60),
        uniform(1.5, 4.5)
    )

    row = tupled(formation, area, height, volume, phase, price, area.iid(), price.iid())

    r = Random(12345)
    for i in range(100):
        print(row.generate(r))

    return 0

if __name__ == '__main__':
    sys.exit(main(sys.argv))fakiris "monad-inspired": there's an explicitbind, but graphs are
implicitly monadic by default.
That is, in the example above,pricegenerates prices corresponding to the
phase generated byphasein a given "generation cycle"---it's as if we really
had written (using the phase and price produced "tupled" byphase_price):phase = choice(['Oil', 'Gas'])
phase_price = phase.bind(
        lambda p: (
            uniform(30, 60) if p == 'Oil' else uniform(1.5, 4.5)
        ).fmap(lambda pr: (p, pr)))To "opt out" of this implicit bind, clone Fakir objects into independent
identically distributed objects with theiidmethod.Why is this a "package" and not a "module"? PEP 561 says that's the only way to get type information distributed (withpy.typed). Someone who actually cares enough to bother should start a petition or something, because this kind of unbridled complexity addiction is what's destroying Python and the last shreds of my sanity.View the fullpdoc3-generated API documentation.Install with:
pip install fakirOr download directlyfrom PyPI.(c) 2020 dwt | terminus data science, LLCavailable under the Apache License 2.0
Package: fakr
Random data, fakrs!fakrreads a Jinja2 Template fromstdin, renders it using a vocabulary and writes the result tostdout. It’s as simple as that…Installation$ pip install fakrBasic Usage$ fakr--helpExamplesGenerate a simple csv file with 100k rows$ echo "{{row}},{{row%100}},{{firstname}},{{lastname}},{{email}}" \
  | fakr --count 100000``Use a file for complex template$ cat examples/templates/vcard.tpl \
  | fakr --count 1000Make a http request using curl:$ echo "company={{company|urlencode}}&city={{city|urlencode}}"  \
  | fakr -c1 \
  | curl httpbin.org/post -d @-Write data to a redis server:$ echo 'firstname \"{{firstname}}\" lastname \"{{lastname}}\" email \"{{email}}\"' \
  | fakr \
  | xargs -i redis-cli HMSET {}``TemplatesThe templates you use for data generation are plainJinja2 Templates. See their reference for detailed information.There are a few custom filters, functions and variables for use with fakr:Custom filters:ascii: Converts the value to ascii (usingUnidecode) (i. e.{{lastname|ascii}})shuffle: Shuffles the value randomly (i. e.{{lastname|shuffle}})chance: Gives the value a chance from 0.0 to 1.0 to be returned (i. e.{{firstname|chance(0.9)}}- firstname will be 90% returned, 10% empty)rjust: Right-justifies the value to the given with (i. e.{{company|rjust(40)}})ljust: Left-justifies the value to the given with (i. e.{{company|ljust(40)}})center: Centers the value in width (i. e.{{company|center(40)}})hash: Calculates the hash with a given hashing algo (i. e.{{email|hash(‘md5’)}})Custom functions:translateuuid4: Returns a new UUIDv4 on every call (i. e.{{uuid4()}})unixtime: Returns a the current unixtime as float in seconds, (i. e.{{unixtime()}})Fixed (vocabulary independent) variables:row: The row (starting from 0) of the current datasetid: The id or sequence number of the current datasetguid: The representation of theidin a uuid-like fashion
Package: fakts
faktsInspirationFakts was designed to make configuration of apps compatible with modern concurrency patterns, it is designed to allow
for asynchronous retrieval of configuration from various sources, may it be a config file, environmental variables
or a remote server (via the "fakts remote protocol", described in the documentation.).Fakts was conceived as a way to provide a configuration interface for thearkitektplatform,
where clients needed to dynamically retrieve configuration from a remote server, but it is designed to be used in any python project.Core DesignFakts usesGrantsto obtain configuration asynchronously, a grant is a way of retrieving the configuration from a
specific source. It can be a local config file (eg. yaml, toml, json), environemnt variables, a remote configuration (eg. from a fakts server), or a database.
TheFaktsclass then wraps the grant to ensure both a sychronous and asychronous interface that is threadsafe.Grants are designed to be composable throughMetaGrantsso by desigining a specifc grant structure, one can
highly customize the retrieval logic. Please check out the documentation for more information.Example:By default fakts follows a key-value structure, where the key is a string, and the value can be any serializable
python object.asyncwithFakts(grant=YamlGrant("config.yaml"))asfakts:config=awaitfakts.aget("group_name")# will return the configuration for the group_name key in the yaml fileorwithFakts(grant=YamlGrant("config.yaml"))asfakts:value=fakts.get("nested.key.path")# will return the configuration for a nested key in the yaml fileFakts should be used as a context manager, and will set the current fakts context variable to itself, letting
you access the current fakts instance from anywhere in your code (async or sync) without specifically passing a referece.ComposabilityYou can compose grants through meta grants in order to load configuration from multiple sources (eg. a local, file
that can be overwritten by a remote configuration, or some envionment variables).Example:asyncwithFakts(grant=FailsafeGrant(grants=[EnvGrant(),YamlGrant("config.yaml")]))asfakts:config=awaitfakts.get("group_name")In this example fakts will load the configuration from the environment variables first, and if that fails,
it will load it from the yaml file.Fakts Remote ProtocolFakts provides the remote grant protocol for retrieval of configuration in dynamic client-server relationships.
With these grants you provide a software manifest for a configuration server (fakts-server), that then grants
the configuration (either through user approval (similar to device code grant)). These grants are mainly used
to setup or claim an oauth2 application on the backend securely that then can be used to identify the application in the
future. These grants are at the moment highly specific to the arkitekt platform and subject to change.
Package: fakturownia-python
Python client library for the Fakturownia APIFree software: MIT licenseDocumentation:https://fakturownia-python.readthedocs.io.FeaturesPending :DQuickstartInstall Fakturownia:pip install fakturownia-pythonRunning TestsDoes the code actually work?$ pipenv install --dev
$ pipenv shell
$ toxWe recommend usingpipenvbut a legacy approach to creating virtualenv and installing requirements should also work.
Please installrequirements/development.txtto setup virtual env for testing and development.CreditsThis package was created withCookiecutterand thewooyek/cookiecutter-pylibproject template.History0.1.0 (2018-01-03)First release on PyPI.
Package: fal
falfal is a serverless Python runtime that lets you run and scale code in the cloud with no infra management.With fal, you can build pipelines, serve ML models and scale them up to many users. You scale down to 0 when you don't use any resources.QuickstartFirst, you need to install thefalpackage. You can do so using pip:pipinstallfalThen you need to authenticate:falauthloginYou can also use fal keys that you can get fromour dashboard.Now can use the fal package in your Python scripts as follows:importfal@fal.function("virtualenv",requirements=["pyjokes"],)deftell_joke()->str:importpyjokesjoke=pyjokes.get_joke()returnjokeprint("Joke from the clouds: ",tell_joke())A new virtual environment will be created by fal in the cloud and the set of requirements that we passed will be installed as soon as this function is called. From that point on, our code will be executed as if it were running locally, and the joke prepared by the pyjokes library will be returned.Next stepsIf you would like to find out more about the capabilities of fal, check out to thedocs. You can learn more about persistent storage, function caches and deploying your functions as API endpoints.
Package: fala-assis
pacotepypiExample of PyPI package.Getting StartedDependenciesYou need Python 3.7 or later to usepacotepypi. You can find it atpython.org.
You also need setuptools, wheel and twine packages, which is available fromPyPI. If you have pip, just run:pip install setuptools
pip install wheel
pip install twineInstallationClone this repo to your local machine using:git clone https://github.com/caiocarneloz/pacotepypi.gitFeaturesFile structure for PyPI packagesSetup with package informationsLicense example
Package: falafel-fava
What kind of food is Falafel?Falafel is a web development framework that bundles libraries and tools, providing an elegant and satisfying web development experience. We believe that there is no need to feel pain when developing software, whether it's a "warp engine" or a web page.
Falafel isn't a new independent or "alien" web Framework. It's just a web framework that provides a standard project with MVC concepts, and a collection of facilities for your web Python project.More here:FalafelAbout Fava CLIFava is the command-line interface (CLI) for Falafel, and the CLI provides several useful commands that can help you as you build your app.Fava is a standalone Python package, but it was designed as a main dependency of Falafel. Its functionality depends on the base Falafel project and it isn't recommended to run just Fava without Falafel files.Fava, our CLI provides tools to facilitate your application development. With Fava you can interact with your favorite database engine, generating migrations, models, and seeds. It is also possible to create routes, controllers and other functionality.Fava is a good friend! :)To view a list of all available Fava commands, you may use the list command:fava -hInstallationYou can install the Fava with PIP package manager.pip install falafel-favaUsageFava allows you to interact with your Falafel application in a development environment.With the CLI it is possible to create migrations, models, routes, controllers, run the development server and other features.Check de commands:Run the development server:fava --server (port)Create a new migration file:fava --make_migration create_userCreate a new database model file:fava --make_model userCreate a new controller file:fava --make_controller userCreate a new Route file:fava --make_route userRun all migrations or only one:fava --db_migrate (migration_name)Generate APP Key:fava --generate_keyYou can find more documentation on the project website:Falafel Docs
Package: fala-parlamentar
fala-parlamentarObtém os discursos dos parlamentares via webscraping mantendo a url para a publicação do textoinstalaçãopip install fala-parlamentarcomo usardiscursos senadoresIn [1]: from fala_parlamentar import get_discursos_senador

In [2]: discursos = get_discursos_senador(3830, "2019-01-01", "2020-01-01") #id do Davi Alcolumbre

In [3]: discursos[0]
Out[3]: 
{'titulo': 'Pronunciamento de Davi Alcolumbre em 12/12/2019',
 'url_texto': 'http://www25.senado.leg.br/web/atividade/pronunciamentos/-/p/texto/463401',
 'transcricao': 'O SR. PRESIDENTE  (Davi Alcolumbre. Bloco/DEM - AP) – Eu gostaria de agradecer a todos que nos honraram com a presença nesta sessão solene. \nE declaro encerrada esta sessão.'}discursos deputadosIn [1]: from fala_parlamentar import get_discursos_deputado

In [2]: discursos = get_discursos_deputado("Domingos Neto", "2019-10-01", "2020-01-01")

In [3]: discursos[18]
Out[3]: 
{'urlTexto': 'https://www.camara.leg.br/internet/sitaqweb/TextoHTML.asp?etapa=5&nuSessao=11.2019&nuQuarto=77720&nuOrador=11&nuInsercao=11&dtHorarioQuarto=17:00&sgFaseSessao=OD&Data=20/02/2019&txApelido=RODRIGO%20MAIA%20(PRESIDENTE),%20DEM-RJ&txFaseSessao=Ordem%20do%20Dia&txTipoSessao=Deliberativa%20Ordin%C3%83%C2%A1ria%20-%20CD&dtHoraQuarto=17:00&txEtapa=',
 'transcricao': 'O SR. PRESIDENTE (Rodrigo Maia. Bloco/DEM - RJ) - Eu já recolhi a sua questão de ordem e vou indeferi-la, porque, por mais que boa parte do texto esteja prejudicada, ainda sobra algo que permanece.Então, infelizmente, não tem como deferir a sua questão de ordem.',
 'titulo': 'Pronunciamento de Rodrigo Maia em 20/02/2019'}
Package: falass
### falassfalass is a pure python library for the calculation of neutron and X-ray reflectometry data from molecular simulation. Currently we support GROMACS output pdb structures, using the `trjconv` command. It is also necessary to know the scattering length of the atoms or beads in your system. For all the elements these can be found freely online. falass will slice your simulation cell into a series of layers and calculate the reflectometry from the Abele matrix formalism. An example Jupyter notebook and dataset is available in the 'example' directory which shows a typical usage of falass.#### DocumentationAPI-level documentation is available at: [http://falass.readthedocs.io/en/latest/](http://falass.readthedocs.io/en/latest/)#### InstallEither clone the repository and install with:```python setup.py buildpython setup.py installpython setup.py test```Or get a build from pip with:`pip install falass`[![Build Status](https://travis-ci.org/arm61/falass.svg?branch=0.0.2)](https://travis-ci.org/arm61/falass)[![Coverage Status](https://coveralls.io/repos/github/arm61/falass/badge.svg?branch=master)](https://coveralls.io/github/arm61/falass?branch=master)[![DOI](https://zenodo.org/badge/112358527.svg)](https://zenodo.org/badge/latestdoi/112358527)