Saravanan666/pypi-org huggingface dataset:
Package: faker-graphics
faker-graphicsProvider forFakerto generate placeholder images withcairo.Includes a random color generator forked from thePython portofrandomColor.jsProvides a simple CLI to generate image files or just colors in the terminalGenerated images show size, aspect ratio and a simple geometryInstallation$pipinstallfaker-graphicsUsage with Faker and/or Factory-BoyRegister the provider with FakerThe faker-graphics provider will reuse Faker's random instance.fromfakerimportFakerfromfaker_graphicsimportProviderfake=Faker()fake.add_provider(Provider)Alternatively register the provider with Faker via Factory-Boyimportfactoryfromfaker_graphicsimportProviderfactory.Faker.add_provider(Provider)Using the "placeholder_image" fakeAfter registration the "placeholder_image" fake is available.
It returns a PNG image as bytes.fromfakerimportFakerfake=Faker()data=fake.placeholder_image()assertdata[:6]==b'\x89PNG\r\n'placeholder_image()accepts the following optional arguments:width: image size in pixels, default: 256height: image size in pixels, default: 256hue: influence the color randomizer, e.g. a hue name like "green", "blue", "pink" (seefgr colormapcommand below) or a number in a 360° spectrum, default:Noneresults in random colorluminosity: "random", "bright", "dark", "light", default:Luminosity.lightUsage with Factory-Boy/DjangoimportfactoryclassModelWithImageFactory(factory.django.DjangoModelFactory):classMeta:model='models.ModelWithImage'image=factory.django.FileField(filename='mock_image.png',data=factory.Faker('placeholder_image',width=640,height=320,hue='green',luminosity='dark',),)CLI UsageThe CLI provides sub commands for various tasks.$fgr--help
Usage:fgr[OPTIONS]COMMAND[ARGS]...faker_graphicscommandlineinterface.

Options:-v,--verboseIncreaseverbosity.--helpShowthismessageandexit.

Commands:colorShowrandomcolorsinyourterminal.colormapShowcolormapusedbyrandomcolorgeneratorasJSON.imageGenerateaplaceholderimagewithrandomhue.All subcommands provide their own--helpmessages!Generate an image via CLICreate image files or write to stdout using-asOUTPUT.$fgrimagesample.pnggreen--size640320--luminositydarkShow colormapThecolormapcommand returns the whole colormap as JSON; you could usejqto extract the known hue names.$fgrcolormap|jq"keys_unsorted"["monochrome","grey","red","orange","yellow","green","cyan","blue","purple","magenta","pink"]Generate random colorsGenerate one or multiple random colors. Colors are returned as HSV/B values and shown as background color if your terminal supports it.$fgrcolorpink--count3--luminositylight--sortedhsv(328,30,98)rgb(249,174,214)#f9aed6hsv(334,55,97)rgb(247,111,170)#f76faahsv(344,26,100)rgb(255,188,206)#ffbcce
Package: fakeriak
Fakeriak is an Apache2 licensed library, written in Python, for testing code
that uses the Python Riak client.A Fakeriak client contains a very simple, in-memory storage backend. An
ordinary Riak client can simply be replaced with a Fakeriak client during unit
testing, thus enabling the testing of components that depend on Riak.test_payload=b'test'riak_client=FakeRiakClient()obj=riak_client.bucket('default').new(content_type='binary/octet-stream')obj.data=test_payloadobj.store()assertriak_client.bucket('default').get(obj.key).data==test_payloadFeaturesonly default, simple bucketsRiakBucket.new,RiakBucket.get,RiakBucket.delete,RiakBucket.multigetRiakObject.store(),RiakObject.delete(),RiakObject.existsno concurrency (sibling) supportInstallationTo install Fakeriak (preferably in a virtualenv), simply:$pipinstallfakeriakContributingContributions are very welcome. Tests can be run withtox, please ensure
the coverage at least stays the same before you submit a pull request.
Package: faker-ids
Hey There !!!This is the simple python package for generating fake id’s. You can fetch upto 5 MILLION fake id’s. The id generated contains 4 elements ‘First Name’, ‘Last Name’, ‘Email Id’ and ‘Mobile Number’. This package provides indian id’s.Input:n: Number of required fake id’s0 < n < 5000000Output:List: List of Json objects which contain the details of the id i.e. first name, last name, email id and mobile number.Installation:pip install faker-idsCode:import faker_idsprint(faker_ids.get_ids(n))
Package: faker-job-brazil
faker_job_brazil=========|pypi| |unix_build| |coverage| |license|faker_job_brazil is a job provider for the `Faker`_ Python package focused on existing brazilian jobs.Usage-----Install with pip:.. code:: bashpip install faker_job_brazilOr install with setup.py.. code:: bashgit clone https://github.com/paladini/faker_job_brazil.gitcd faker_job_brazil && python setup.py installAdd the ``BrazilJobProvider`` to your ``Faker`` instance:.. code:: pythonfrom faker import Fakerfrom faker_job_brazil import BrazilJobProviderfake = Faker()fake.add_provider(BrazilJobProvider)fake.profissao()# 'Engenheiro de som'fake.profissao()# 'Terapeuta floral'.. |pypi| image:: https://img.shields.io/pypi/v/faker_web.svg?style=flat-square&label=version:target: https://pypi.python.org/pypi/faker_job_brazil:alt: Latest version released on PyPi.. |license| image:: https://img.shields.io/badge/license-apache-blue.svg?style=flat-square:target: https://github.com/paladini/faker_job_brazil/blob/master/LICENSE:alt: Apache license version 2.0.. _Faker: https://github.com/joke2k/faker
Package: fakerlocationer
FakerLocationerA simple class that can be used to fake Selenium Browser GeolocationGetting StartedIts very easy to get started with using fakerlocationer. A simple example is shown in usage.py or you can see it below:'''
from fakerlocationer import FakerLocationer
from selenium import webdriverdriver = webdriver.Chrome()
driver.get("http://www.mylocation.org")
f = FakerLocationer(driver)
f.setLocation(50, 50)
'''pythonThe only drawbacks of fakerlocationer are that in order for the geolocation to change the page must be fully loaded, and if the page refreshes/changes it'll reset the geolocationPrerequisitesPretty much only need Selenium and Python 3InstallingCan be installed by using pip:'''
pip3 install fakerlocationer
'''Or just by literally downloading fakerlocationer.py and importing it into your projectBuilt WithSelenium- Selenium FrameworkAuthorskenevil1-kenevil1See also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsTo Selenium for making the web testing suite :)
Package: faker-marketdata
faker_marketdataGenerates random, valid market identifiers following most common formats in the industry.Installationpipinstallfaker_marketdataUsageAdd as a provider to yourFakerinstance:>>>fromfakerimportFaker>>>fromfaker_marketdataimportMarketDataProvider>>>fake=Faker()>>>fake.add_provider(MarketDataProvider)Optionally you can define a seed value to have repeatable identifiers:>>Faker.seed(123)>>fake.add_provider(MarketDataProvider())Now you can start to generate market identifiers, some examples:>>fake.isin()# "GTYMQXUIYPB6">>fake.sedol()# "NKDEKC8">>fake.cusip()# "Z57XGDJW7">>fake.ticker()# "GRTT"DocumentationSupported market data formats:ISINSEDOLMICLEICUSIPRICTICKERNSINFIGIMarket type (e.g. "bond", "commodity", "otc")
Package: faker-microservice
faker-microserviceProvider forFakerwhich adds fake microservice names.Installationpipenv install faker-microserviceUsagePythonfromfakerimportFakerimportfaker_microservicefake=Faker()fake.add_provider(faker_microservice.Provider)print(fake.microservice())# prints "fulfilment_manager" or similarCommand Linepipenv run faker microservice -i faker_microservice
Package: faker_music
faker_music: music provider for FakerAn add-on provider for the Python Faker module to generate random and/or fake data for music-related categories.Descriptionfaker_musicprovides music-related fake data for testing purposes.  The definition of "fake" in this context really means "random," as the musical data are real. Invocation of this module simply provides a random choice from the underlying real-world data.No claims are made as to the accuracy or completeness of this data. However, suggestions/corrections/additional data are happily accepted.Currently implemented:Music genresMusical instrumentsComing soon:ComposersPerformersFor future implementation:Band names (existing)Fake band name generatorTheory (notes/scales/chord-types/progressions)...?InstallationFrom PyPi:pipinstallfaker_musicFrom source code:gitclonehttps://github.com/jeffwright13/faker_music/cdfaker_music&&pythonsetup.pyinstallExecutionAdd as a provider to your Faker instance:>>>fromfakerimportFaker>>>fromfaker_musicimportMusicProvider>>>fake=Faker()>>>fake.add_provider(MusicProvider)Now you can start to generate data:>>>fake.music_genre()>>>fake.music_subgenre()>>>fake.music_instrument()>>>fake.music_instrument_category()About faker_music ObjectsThemusic_genre_objectis a dictionary consisting of a 'genre' string, and an associated 'subgenre' list. The purpose is to provide data that ties together a given genre with all of it known subgenres.For example:>>>fake.music_genre_object(){'genre':'Singer/Songwriter','subgenres':['Alternative Folk','Contemporary Folk','Contemporary Singer/Songwriter','Indie Folk','Folk-Rock','Love Song','New Acoustic','Traditional Folk']}Similarly, Themusic_instrument_objectis a dictionary consisting of an instrument 'category' string, and an associated 'instrument' list. The purpose is to provide data that ties together a given caegory with all of it known instruments.For example:>>>fake.music_instrument_object(){'category':'electronics','instruments':['Drum machine','Electric guitar','Keyboard','Synthesizer','Theremin','Turntable']}Data SourcesOriginal data for this project (stored ingenres.py,instruments.py) was lifted fromhttps://www.musicgenreslist.comandWikipedia, and massaged into a format suitable for coding using thegenre_parser.pyandinstrument_parser.pycodefound here.AcknowlegementsI would like to thank the maintainer of thefaker_airtravelrepository, since I used its structure to create this one.Big thanks also toBob Belderbosfor his expert guidance in getting this litte project off the ground.
Package: faker-optional
Faker OptionalWrapper over other Faker providers to return their value orNone. Useful to
create data of typeOptional[Any].HelpSeedocumentationfor more details.Installingpipinstallfaker-optionalContributingFor guidance on setting up a development environment, and how to make
a contribution tofaker-optional, seeContributing to
faker-optional.LicenseGPLv3
Package: faker-pandas
Faker PandasfromfakerimportFakerfromfaker_pandasimportPandasProviderfake=Faker()fake.add_provider(PandasProvider)colgen=fake.pandas_column_generator()df=fake.pandas_dataframe(colgen.first_name('First Name',empty_value='',empty_ratio=.5),colgen.last_name('Last Name'),colgen.pandas_int('Age',18,80,empty_ratio=.2),rows=7)print(df)Output:First Name Last Name   Age
1             Lawrence  72.0
2       Lisa  Holloway   NaN
3              Edwards  31.0
4     Steven   Johnson  69.0
5                Smith  66.0
6     Monica     Lynch   NaN
7     Edward     Brown  20.0
Package: fakeRPiGPIO
fakeRPiGPIOThis package is used to simulate theRPi.GPIOmodule.
This package only contains the functions in the RPi.GPIO package without
the functionality. Useful to debug code outside the RPi.
To avoid printing the function calls to the package, setVERBOSEtoFalse:fromRPiimportGPIOGPIO.VERBOSE=Falsemore_code()The following functions have minimal functionality without any error
checking:setmode,getmode,gpio_function,setup,output,input,cleanup.LicensePython fake RPi.GPIO library
Copyright (C) 2020 Luiz Eduardo Amaralluizamaral306@gmail.comThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program.  If not, seehttp://www.gnu.org/licenses/.
Package: fake-rpigpio
fake-rpigpiofake-rpigpiois a package intended to provide a lightweight (dependency-free) fake
interface for Raspberry Pi GPIO. The GPIO functions match those in theRPi.GPIOlibrary, however the functions do nothing. This makes it easier to test GPIO-related code
and to get the code to run on non-pi machines.InstallationThis package can be installed via pip:pip install fake-rpigpioUsageA basic example of using this package to run withRPi.GPIOon a Pi andfake-rpigpioon
a non-Pi:try:importRPi.GPIOexcept(RuntimeError,ModuleNotFoundError):importfake_rpigpio.utilsfake_rpigpio.utils.install()This will installfake-rpigpio.RPiasRPiandfake-rpigpio.RPi.GPIOasRPi.GPIO,
so you should not need to change imports for theRPi.GPIOlibrary.AcknowledgementsThe following projects inspired this one. While all are similar, the usage and dependency
weight varies between projects.fake_rpifakeRPiGPIO
Package: faker-pyspark
PySpark provider for Fakerfaker-pysparkis a PySpark DataFrame and Schema (StructType) provider for theFakerPython package.Descriptionfaker-pysparkprovides PySpark based fake data for testing purposes.  The definition of "fake" in this context really means "random," as the data may look real.  However, I make no claims about accuracy, so do not use this as real data!InstallationInstall with pip:pipinstallfaker-pysparkAdd as a provider to your Faker instance:fromfakerimportFakerfromfaker_pysparkimportPySparkProviderfake=Faker()fake.add_provider(PySparkProvider)PySpark DataFrame, Schema and more>>>df=fake.pyspark_dataframe()>>>schema=fake.pyspark_schema()>>>df_updated=fake.pyspark_update_dataframe(df)>>>column_names=fake.pyspark_column_names()>>>data=fake.pyspark_data_dict_using_schema(schema)>>>data=fake.pyspark_data_dict()CLIfaker$fakerpyspark_schema-ifaker_pyspark
$fakerpyspark_dataframe-ifaker_pyspark
$fakerpyspark_schema-ifaker_pyspark
$fakerpyspark_column_names-ifaker_pyspark
$fakerpyspark_data_dict-ifaker_pyspark
Package: faker-security
Faker-SecurityProvider forFakerto generate random/fake data related to security.RequirementsFakerPython 3.8+Installation and UsageIf you want to usefaker-securitywithin your project, add it to your dependency file of choice.This is typically your project'srequirements.txtfile. If you are using a higher-level package manager likepoetryorpipenv, follow their instructions for adding new packages.Once installed, you need to setupFakerto make use of theSecurityProvider. An example of how that could be done is shown below:fromfakerimportFakerfromfaker_security.providersimportSecurityProviderfake=Faker()fake.add_provider(SecurityProvider)# generate a CVSSv3 vectorfake.cvss3()Provider Featurescvss3: generates a CVSS v3 vectorcvss2: generates a CVSS v2 vectorccss: generates a CCSS vectorversion: generates asemver version numbernpm_semver_range: generates anpm compatible semver version rangecwe: generates a CWE identifiercve: generates a CVE identifierDevelopingInstallpoetryand runpoetry installInstallpre-commitand runpre-commit install --install-hooksTestingpoetry run pytestto run tests.
Package: faker_sqlalchemy
SQLAlchemy Fakeris a provider for theFakerlibrary that helps populateSQLAlchemy ORMmodels with dummy data. Creating a new instance of a model can be as simple as callingfake.sqlalchemy_model(SomeModel).InstallationThe recommend way to install SQLAlchemy Faker is withpip:pip install faker_sqlalchemyExampleSay you have some model declared using SQLAlchemy’s ORM.>>> class SomeModel(Base):
...     __tablename__ = "some_model"
...
...     id = Column(Integer, primary_key=True)
...
...     value = Column(String)And, you want to easily generate some data,>>> from faker_sqlalchemy import SqlAlchemyProvider
>>>
>>> fake = Faker()
>>> fake.add_provider(SqlAlchemyProvider)
>>>
>>> instance = fake.sqlalchemy_model(SomeModel)Useinstanceas desired.>>> print(instance.value)
RNvnAvOpyEVAoNGnVZQUSupported VersionsCurrently SQLAlchemy versions 1.3 and 1.4 are supported. Support for SQLAlchemy 2.0 will be added when it is released.Faker versions>=8are currently supported, though it should be noted that the testing matrix isn’t exhaustive. If
bugs come up with a particular version of faker beyond version 8.0, submit a ticket to add support.Python versions>=3.7are currently supported. If python 3.6 support is desired, submit a ticket to add support. Support
for Python 3.11 will be added when it is officially supported by SQLAlchemy. Currently, this is waiting on greenlet
releasing support for python 3.11.
Package: faker-stalker-names
faker-stalker-namesFaker-stalker-namesis a provider for theFakerPython package that allows you
to generate stalker names for your tests and other tasks.Don't forget your friends) (с) Slava SmartassLocalizationsThe following localizations are present:de_DE,en_US,es_ES,fr_FR,it_IT,pl_PL,ru_RU,uk_UAInstallationFrom PyPi:pip3 install faker-stalker-namesUsageJust add theProviderto yourFakerinstance:from faker import Faker
from faker_stalker_names.en_US import Provider as StalkerNamesProvider

fake = Faker()
fake.add_provider(StalkerNamesProvider)Or pass it to the constructor:from faker import Faker

fake = Faker(includes=["faker_stalker_names"], locale="ru_RU")Now you can start to generate data:fake.stalker_name()
# Яшка Нытик

fake.stalker_first_name()
# Саня

fake.stalker_last_name()
# РезкийYou can specify the desired type of name (stalkerorbanditare available).
By default, the first and last names are randomly selected.fake.stalker_name(name_type="stalker")
# Slava Smartass

fake.stalker_first_name(name_type="bandit")
# VasyanIn addition, a way to replace the standardnamemethod at your own risk:StalkerNamesProvider.name = StalkerNamesProvider.stalker_name
fake = Faker()
fake.add_provider(StalkerNamesProvider)
fake.name()
# Shurik Professor
Package: faker-starship
faker-starshipis a provider of various starship data for theFakerPython package. faker-starship pulls randomly from a static library of thousands of fictional starship names, classes, and registry numbers spanning multiple sci-fi universes.InstallationInstall with pip (or pipenv):pip install faker-starshipUsagePythonAdd thefaker_starship.Providerto yourfaker.Fakerinstance:importfakerimportfaker_starshipfake=faker.Faker()fake.add_provider(faker_starship.Provider)To get a starship name, class, or registry number from across the multiverse:print(fake.starship_name())# prints "Colonial One" or similarprint(fake.starship_class())# prints "K't'inga" or similarprint(fake.starship_registry())# prints "ECS-222" or similarOr to limit to a specific source universe:print(fake.starship_name("starwars"))# prints "Millennium Falcon" or similarprint(fake.starship_class("eveonline"))# prints "Nyx" or similarprint(fake.starship_registry("theorville"))# prints "ECV-197" or similarCommand Linefaker starship_name -i faker_starship
faker starship_class -i faker_starship
faker starship_registry -i faker_starshipAdditional InformationLicense:MITReleases:https://pypi.org/project/faker-starship/Code:https://gitlab.com/infinitewarp/faker-starshipTest status:https://gitlab.com/infinitewarp/faker-starship/pipelines/?scope=branchesTest coverage:https://codecov.io/gl/infinitewarp/faker-starship/branch/master
Package: faker-vehicle
faker_vehicle is a provider for theFakerPython package.It provides vehicle and machinery related fake data for testing purposes:Vehicle MakeVehicle ModelVehicle Make / ModelVehicle Make / Model / YearVehicle Make / Model / CategoryVehicle YearVehicle Object (you can format)Machine MakeMachine ModelMachine Make / ModelMachine Make / Model / YearMachine Make / Model / CategoryMachine YearMachine Object (you can format)UsageInstall with pip:pipinstallfaker_vehicleOr install with setup.pygitclonehttps://github.com/kennethwsmith/faker_vehicle.gitcdfaker_vehicle&&pythonsetup.pyinstallAdd theVehicleProviderto yourFakerinstance:fromfakerimportFakerfromfaker_vehicleimportVehicleProviderfake=Faker()fake.add_provider(VehicleProvider)fake.vehicle_year_make_model()# 2014 Volkswagen Golffake.vehicle_year_make_model_cat()# 1996 Dodge Ram Wagon 1500 (Van/Minivan)fake.vehicle_make_model()# Volvo V40fake.vehicle_make()# BMWfake.vehicle_model()# SLfake.vehicle_year()# 2008fake.vehicle_category()# Wagonjson.dumps(fake.vehicle_object())# {"Year": 1996, "Make": "Chrysler", "Model": "New Yorker", "Category": "Sedan"}fake.machine_year_make_model()# 2008 Caterpillar 5511Cfake.machine_year_make_model_cat()# 2008 Caterpillar 5511C (Feller Buncher)fake.machine_make_model()# Caterpillar 5511Cfake.machine_make()# Caterpillarfake.machine_model()# 5511Cfake.machine_year()# 2008fake.machine_category()# Feller Buncherjson.dumps(fake.machine_object())# {"Year": 2008, "Make": "Caterpillar", "Model": "5511C", "Category": "Feller Buncher"}
Package: faker-web
faker_web is a provider for theFakerPython package.It provides web-related fake data for testing purposes:Content-type http header.Popular web server version tokens/signatures.UsageInstall with pip:pipinstallfaker_webOr install with setup.pygitclonehttps://github.com/thiagofigueiro/faker_web.gitcdfaker_web&&pythonsetup.pyinstallAdd theWebProviderto yourFakerinstance:fromfakerimportFakerfromfaker_webimportWebProviderfake=Faker()fake.add_provider(WebProvider)fake.content_type()# application/mxffake.content_type_popular()# text/htmlfake.server_token()# Apache/2.0.51 (Ubuntu)
Package: faker-web3
faker_web3Web3-related fake data provider for Python FakerInstallationpip install faker_web3Usage:fromfakerimportFakerfromfaker_web3importWeb3Providerfake=Faker()fake.add_provider(Web3Provider)Private keysfake.web3_private_key()# 0x1db498f960c133fd83351160687c91b6e41340959c9f03a810e8078f062562d1
Package: faker-wifi-essid
Fakerprovider for Wi-Fi ESSIDs.Usage# Import Faker.fromfakerimportFaker# Import the WifiESSID class from Faker Wi-Fi ESSID.fromfaker_wifi_essidimportWifiESSID# Create an instance of Faker.fake=Faker()# Add Faker Wi-Fi ESSID to the Faker providers.fake.add_provider(WifiESSID)# Call 'wifi_essid()' to get a random fake Wi-Fi ESSID.fake.wifi_essid()LicenseMIT
Package: fake-server
A fake server than catch all path and response success message or whatever data you defined.Usagepython -m fake_server Success!Then you can access whatever path in 'http://127.0.0.1' (such ashttp://127.0.0.1/simple/a/b/c), and then get response text 'Success!'.All arguments:python -m fake_server -t TEXT -f FILE_PATH -fc FILE_PATH -b 127.0.0.1:80SERVER ARGUMENTS-b --bind: Server bind host and port, default 127.0.0.1:80, if you what listen on all interface just use 0.0.0.0:80-p --port: Server bind port, same as port in --bindRESPONSE ARGUMENTSYou can only choice one argument for response-t --text: Return text, default Success-f --file FILE_PATH: Return file as attachment-fc --file_content FILE_PATH: Return file contentWhy you need this?When you notice some software send your private data to their server(like: http://data.old_server.com ), and
the software need success response from server(like: {"result": "success"}), what can you do?
Now ,with fake_server, you can do like this:Add this line to your hosts file (Linux/macOS: /etc/hosts, Windows: C:\Windows\System32\Drivers\etc\hosts)127.0.0.1 data.old_server.comStart fake server:
python -m fake_server '{"result": "success"}'Then all data send to data.old_server.com will now send to your own compute, and software will get normal response as before!TODOTo real command line tool as fake-server;Support https