Saravanan666/pypi-org huggingface dataset:
Package: carta-ach
carta-achACH file generator module for python. So far, this has been tested with
“PPD” and “CCD” batches with addenda records.
Forked frompython-achby Travis Hathaway and released on PyPI ascarta-ach.ExampleBelow is an example of how to use the module:fromach.builderimportAchFilesettings={'immediate_dest':'123456789',# Your bank's routing number'immediate_org':'123456789',# Bank assigned routing number'immediate_dest_name':'YOUR BANK','immediate_org_name':'YOUR COMPANY','company_id':'1234567890',#tax number}ach_file=AchFile('A',settings)#file Id modentries=[{'type':'22',# type of'routing_number':'12345678','account_number':'11232132','amount':'10.00','name':'Alice Wanderdust','addenda':[{'payment_related_info':'Here is some additional information',},],},{'type':'27','routing_number':'12345678','account_number':'234234234','amount':'150.00','name':'Billy Holiday',},{'type':'22','routing_number':'12323231','account_number':'123123123','amount':'12.13','name':'Rachel Welch',},]ach_file.add_batch('PPD',entries,credits=True,debits=True)printach_file.render_to_string()This returns the following NACHA file:101 123456780 1234567801409020123A094101YOUR BANK              YOUR COMPANY
5200YOUR COMPANY                        1234567890PPDPAYROLL         140903   1123456780000001
62212345678011232132         0000001000               ALICE WANDERDUST        1123456780000001
705HERE IS SOME ADDITIONAL INFORMATION                                             00000000001
627123456780234234234        0000015000               BILLY HOLIDAY           0123456780000002
622123232318123123123        0000001213               RACHEL WELCH            0123456780000003
820000000400370145870000000150000000000022131234567890                         123456780000001
9000001000001000000040037014587000000015000000000002213
9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
Package: car-talk-archiver
Car Talk ArchiverA script that generates an RSS XML feed containing every Car Talk episode currently hosted by NPR, dating back to 2007. Host via HTTP and update with a program like crontab for maximum effect.Compatible with any podcast application that supports RSS.Requirementspython = "^3.10"
beautifulsoup4 = "^4.11.2"
feedgen = "^0.9.0"
requests = "^2.28.2"Installationpip install car-talk-archiverUsageusage: cta.py [-h] [-i file] [-o file]

Generate a podcast RSS feed containing every Car Talk episode currently hosted by NPR.

options:
  -h, --help            show this help message and exit
  -i file, --input file
                        file name of an existing feed (if specified, script will only check for newer episodes)
  -o file, --output file
                        output file name (defaults to cartalk_<timestamp>.xml in current working directory)ExamplesGenerate a new feed:$ ./cta.pyUse an existing feed to generate a new feed including the most recent episodes:$ ./cta.py -i cartalk.xmlUpdate and overwrite an existing feed with the most recent episodes:$ ./cta.py -i cartalk.xml -o cartalk.xml
Package: cartAMDI
Django Shopping Cart is a Django app to store product in cart.Detailed documentation is in the “docs” directory.Quick startAdd “cart” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'cart',
]

Add below line to settings context_processor::
    'cart.context_processor.cart_total_amount'

CART_SESSION_ID = 'cart'You can use the urls in following way:from django.urls import path
from . import views

urlpatterns = [
    path('cart/add/<int:id>/', views.cart_add, name='cart_add'),
    path('cart/item_clear/<int:id>/', views.item_clear, name='item_clear'),
    path('cart/item_increment/<int:id>/',
         views.item_increment, name='item_increment'),
    path('cart/item_decrement/<int:id>/',
         views.item_decrement, name='item_decrement'),
    path('cart/cart_clear/', views.cart_clear, name='cart_clear'),
    path('cart/cart-detail/',views.cart_detail,name='cart_detail'),
]You should have a Product model & Below field is mandatoryname = models.CharField(max_length=255)
image = models.ImageField(upload_to=’products/’)
price = models.FloatField()Then views.py should like like this:from django.shortcuts import render, redirect
from store.models import Product
from django.contrib.auth.decorators import login_required
from cart.cart import Cart

@login_required(login_url="/users/login")
def cart_add(request, id):
    cart = Cart(request)
    product = Product.objects.get(id=id)
    cart.add(product=product)
    return redirect("home")


@login_required(login_url="/users/login")
def item_clear(request, id):
    cart = Cart(request)
    product = Product.objects.get(id=id)
    cart.remove(product)
    return redirect("cart_detail")


@login_required(login_url="/users/login")
def item_increment(request, id):
    cart = Cart(request)
    product = Product.objects.get(id=id)
    cart.add(product=product)
    return redirect("cart_detail")


@login_required(login_url="/users/login")
def item_decrement(request, id):
    cart = Cart(request)
    product = Product.objects.get(id=id)
    cart.decrement(product=product)
    return redirect("cart_detail")


@login_required(login_url="/users/login")
def cart_clear(request):
    cart = Cart(request)
    cart.clear()
    return redirect("cart_detail")


@login_required(login_url="/users/login")
def cart_detail(request):
    return render(request, 'cart/cart_detail.html')In the template you can use the url in folowing way:<a href="{% url 'cart_add' product.id %}">Add To Cart</a>
<a href="{% url 'cart_clear' %}">Clear Cart</a>
<a href="{% url 'item_increment' value.product_id %}">Increament</a>
<a href="{% url 'item_decrement' value.product_id %}">Decrement</a>To view the cart detail page use the below code{% load cart_tag %}Total Length :: {{request.session.cart|length}}Cart Detail:{% for key,value in request.session.cart.items %}{{value.name}}
{{value.price}}
{{value.quantity}}
{{value.image}}
Total {{ value.price|multiply:value.quantity }}{% endfor %}
Package: carte
CarteCarteis a flexible, extensible reverse-geocode library implemented in Python.InstallationFromPyPIviapipCarteis available from PyPI viapip.pipinstallcarteFrom source usingpoetryNote:It is recommended to buildcartein a virtual environment due to dependency version requirements.From the root of the repository, install the necessary dependencies viapoetry:poetryinstallThen, build the wheel:poetrybuildFinally, outside of your virtual environment, install the wheel usingpip:pipinstalldist/carte-<version>-py3-none-any.whlUsageCarte is built using resources which inherit from theResourceclass. ACarteinstance is instantiated with a list of theResourcetypes it will query:importcartecarte_instance=carte.Carte([my_resource_type])results=carte_instance.query(Listofcoordinatesastuples...)MultipleCarteinstances may be created, and resources will be shared between them by a backingResourceStore.Custom ResourcesThe flexibility of Carte lies in theResourceclass, which queries are passed to sequentially via thequerymethod. The results of each resource query are aggregated and passed to the next, allowing the creation of resources that mutate previous resources' results, such as translating a country's ISO 3166-1 identifier code into a full name.For examples ofResourceclasses, see theresourcessubmodule.Defining your ownResourceis as simple as inheriting from theResourcesuperclass, and implementing theloadandquerymethods.fromcarte.resourcesimportresourceclassMyCustomResource(resource.Resource):defload(self):# do stuff...defquery(self,coordinates,results)->dict:# do other stuff...returnresultsTestingTo run tests, execute the following from the root of the project:poetryrunpytesttests/LicenseCarteis licensed under theGNU Lesser General Public License.AttributionCarteis inspired byreverse-geocode.
Package: carte-cli
CarteCarte is a Python library for extracting metadata from your data sources and generating structured Markdown files from it. It can also scaffold an MkDocs based static site that provides an easy to use, fully searchable UI that you can simply upload to any static site hosting provider. Carte currently supports the AWS Glue catalog, PostgreSQL, and JSON schemas (only basic support). More sources are coming soon. (You can also use sources from theAmundsen Databuilderlibrary with a bit of scripting, seethe docsfor details)Installationpipinstallcarte-cliIf you plan to use PostgreSQL as a data source, you should also install the related optional dependencies using the following command instead of the first one:pipinstallcarte-cli[postgres]UsageSeethe docs
Package: cartes
CartesCartes is a Python library providing facilities to produce meaningful maps.Cartes builds on top of most common Python visualisation libraries (Matplotlib/Cartopy, Altair, ipyleaflet) and data manipulation libraries (Pandas, Geopandas) and provides mostly:acomprehensive set of geographic projections, built on top of Cartopy and Altair/d3.js;aninterface to OpenstreetMap Nominatim and Overpass API. Result of requests are parsed in a convenient format for preprocessing and storing in standard formats;beautifuldefault parametersfor quality visualisations;advanced caching facilities. Do not download twice the same content in the same day.The cartes library is a powerful asset topublish clean, lightweight geographical datasets; and toproduce decent geographical visualisationsin few lines of code.GalleryMore in thedocumentationInstallationLatest release:Recommended, with conda:condainstall-cconda-forgecartesor with pip:pipinstallcartesDevelopment version:gitclonehttps://github.com/xoolive/cartescdcartes
pipinstall.DocumentationDocumentation available athttps://cartes-viz.github.io/
Package: cartesian-explorer
Cartesian ExplorerA handy tool to map functions over their domains.Works:Map over cartesian product of arguments: pass arrays of values for function argumentBuilt-in cachingHandy plotting utilitiesResolving dependencies between functions that require and provide variablesUsageMapfromcartesian_explorerimportExplorerexplorer=Explorer()defmy_function(x,y):returnx+ydata=explorer.map(my_function,x=range(5),y=range(3))print(data)assertdata.shape==(5,3)assertdata[1,2]==my_function(1,2)Cachefromcartesian_explorerimportExplorerexplorer=Explorer()mock=MagicMock()my_function=mock.my_functionwrapped=explorer.cache_function(my_function)wrapped(a=1,b=2)wrapped(a=1,b=2)my_function.assert_called_once_with(a=1,b=2)TODO[ ] Interpolation, extrapolation[ ] Vectorized providers[x] Plot distribution props along additional distribution varHistory0.1.12 (2020-09-29)Row-level variables: now can visualize 4 dimensions0.1.3 (2020-09-29)Joblib disc caching and parallelismDependency graph visualization with networkxPlot-level variables0.0.1 (2020-09-23)First release on PyPI.
Package: cartesio
cartesioSimple geometry accelerated with NumbaFree software: MIT licenseDocumentation:https://cartesio.readthedocs.io.FeaturesBounding Box IOUCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-07-02)First release on PyPI.0.1.1 (2020-07-04)Working Github actions, tox and flake8.0.2.0 (2020-09-01)BBox intersection over union (IOU)CoverageBlack code formatting0.3.0 (2020-10-25)BBox non maxima suppression (NMS)Performance tests
Package: carthage
Carthage is anInfrastructure as Code (IAC)framework.
Carthage provides models for infrastructure concepts such as machines, networks, and domains or groups of machines.  There are concrete implementations of these models including containers and virtual machines.Carthage allows experts to quickly construct infrastructure from a Carthage layout.  Infrastructure can be real, virtual, or a mixture.  Often the same layout is used to produce both real and virtual infrastructure.Examples of applications written using Carthage include:A test framework to run tests against a distributed product by replicating virtual network infrastructure and running tests against that structure.A cyber training application to produce training environments with thousands of virtual machines and realistic training environments including firewalls, routers, and Internet services.  The training environment is entirely isolated from the Internet.A devops application to maintain the real infrastructure on which the cyber training environment runs.Installing CarthageCarthage typically requires  a container environment as well as a virtualization requirement.  On Debian or Ubuntu systems, install the following:apt install socat systemd-container libvirt-clients qemu-utils bridge-utils fai-setup-storage
apt install --no-install-recommends fai-server dosfstoolsYou may also want eitherpython3-pyvmomiorlibvirt-daemon-system.Then install Carthage like any other source distribution, perhaps usingpython3 setup.py installorpython3 setup.py install--user.Alternatively you canpodman pull ghcr.io/hadron/carthage:latestLearning CarthageDocumentation is availablehere.For a look at a sample application take a look athttps://github.com/hartmans/industrial-algebra.carthage.  This application configures the laptop of one of the Carthage developers.Join UsAs you start to use Carthage, you will probably have questions.  The best approach is to discuss them in real time on ourMatrix chat <https://matrix.to/#/#carthage-users:matrix.org>.
Package: carthage-copy-frameworks
carthage-copy-frameworksOverviewcarthage-copy-frameworksis an helper script that you can use to automatically copy every
framework belowCarthage/Build/iOS. This way you can avoidthe official, error prone,
process.As the name implies, this is meant to be used in iOS development, alongsideCarthage.Installationbrew install lvillani/tap/carthage-copy-frameworksUsageOpen your target configuration.Click on "Build Phases".Click on the plus ("+") button.Click on "New Run Script Phase"In the script text field typecarthage-copy-frameworks, as shown in the picture.NotesFrameworks are copied only once. There are no checks to copy a framework again once it changes. This
means that updated dependencies might not be picked up until you perform a clean build.
Package: carto-auth
carto-authPython library to authenticate withCARTO.Installpipinstallcarto-authTo install the CARTO DW extension:pipinstallcarto-auth[carto-dw]Installing from sourcegitclonehttps://github.com/cartodb/carto-authcdcarto-auth
pipinstall.Usagefromcarto_authimportCartoAuth# Authenticationcarto_auth=CartoAuth.from_oauth()# carto_auth = CartoAuth.from_m2m("./carto_credentials.json")# Get api base urlapi_base_url=carto_auth.get_api_base_url()# Get access tokenaccess_token=carto_auth.get_access_token()# CARTO Data Warehousecarto_dw_project,carto_dw_token=carto_auth.get_carto_dw_credentials()carto_dw_client=carto_auth.get_carto_dw_client()For more information, check theexamplessection.DevelopmentMake commands:init: create the environment and install dependencieslint: run linter (black + flake8)test: run tests (pytest)docs: build the documentationpublish-pypi: publish package in pypi.orgpublish-test-pypi: publish package in test.pypi.orgclean: remove the environmentCheck the developmentdocumentationsection.ContributorsJesús ArroyoÓscar Ramírez
Package: cartodb_backup
Python CLI to make a backup of an entire CartoDB domain to SQL dump file
(zipped).Optional:You can restore SQL dumped file to a new (created) PostGIS DB.You can upload sql files to Amazon S3.Message from Amazon SNS (Simple Notification Service).Before execute this script you need a cartodbbkconfig.py file properly
formed (See cartodbbkconfig_example.py).cartodbbkconfig.py config parameters:confparams={"cdb_apikey":"here your api key","cdb_domain":"here your domain","sql_folderpath":"here your dump folderpath","pg_user":"here your db admin user","pg_pswd":None,# If you leave the password to None, the program will ask you in the command line interface"pg_dbase":"here your db name","pg_host":"here your db host","pg_port":"here your db port","pg_newdatabase":"here your new db name","aws_acckey":"here your AWS Acces Key","aws_seckey":"here your AWS Secret Key","aws_bucket":"here your AWS bucket","aws_prekey":"here your AWS bucket prefix key","sns_regname":"here your AWS region name","sns_arn":"here your SNS ARN","sns_subject":"My project"}InstallationYou can install this package from PYPI:https://pypi.python.org/pypi/cartodb_backup$pipinstallcartodb_backupYou can also install it in this way:$pythonsetup.pyinstallUsagePython CLI:$cartodb_backup[-h]configfile[--postgis_backup][--aws_s3upload][--amz_sns][--rmv_localfl]positionalarguments:configfileConfigfilepath:/folderlocation/optionalarguments:-h,--helpshowthishelpmessageandexit--postgis_backupPOSTGIS_BACKUPPostGISbackup(restoringdumpfilecreated)--aws_s3uploadUploadfiletoAmazonS3--amz_snsAmazonSNSmessage--rmv_localflRemovelocalfileafterasuccessfullyAmazonS3uploadExample without PostGIS backup:$cartodb_backup/folderlocation/Example with PostGIS backup:$cartodb_backup/folderlocation/--postgis_backupExample with Amazon S3 upload:$cartodb_backup/folderlocation/--aws_s3uploadExample with Amazon S3 upload and Amazon SNS (removing local sql folder
after upload):$cartodb_backup/folderlocation/--aws_s3upload--amz_sns--rmv_localflRequirementsGDAL >= 1.11.PostgreSQL with PostGIS (1).Psycopg2 Python library (1).Python interface to Amazon Web Services (Boto) (2).Only if you want to use –postgis_backup parameter.Only if you want to use –aws_s3upload parameter.About authorDeveloped by Cayetano Benavent. GIS Analyst at Geographica.http://www.geographica.gsLicenseThis 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 2 of the License, or (at your
option) any later version.
Package: cartoframes
A Python package for integratingCARTOmaps, analysis, and data services into data science workflows.Python data analysis workflows often rely on the de facto standardspandasandJupyter notebooks. Integrating CARTO into this workflow saves data scientists time and energy by not having to export datasets as files or retain multiple copies of the data. Instead, CARTOframes give the ability to communicate reproducible analysis while providing the ability to gain from CARTO’s services like hosted, dynamic or static maps andData Observatoryaugmentation.Try it OutStable (1.2.5):Latest (develop branch):If you do not have an API key, you can still use cartoframes for creating maps locally.The example context only provides read access, so not all cartoframes features are available. For full access,Start a free trialor get free access with aGitHub Student Developer Pack.FeaturesCreate interactive maps from pandas DataFrames (CARTO account not required)Publish interactive maps to CARTO’s platformWrite and read pandas DataFrames to/from CARTO tables and queriesCreate customizable, interactive CARTO maps in a Jupyter notebook using DataFrames or hosted dataAugment your data with CARTO’s Data ObservatoryUse CARTO for cloud-based analysisCommon UsesVisualize spatial data programmatically as matplotlib images, as notebook-embedded interactive maps, or published map visualizationsPerform cloud-based spatial data processing using CARTO’s analysis toolsExtract, transform, and Load (ETL) data using the Python ecosystem for getting data into and out of CARTOData Services integrations using CARTO’sLocation Data StreamsMore infoComplete documentation:https://carto.com/developers/cartoframes/Source code:https://github.com/CartoDB/cartoframesBug tracker / feature requests:https://github.com/CartoDB/cartoframes/issuescartoframesusers must have a CARTO API key for mostcartoframesfunctionality. For example, writing DataFrames to an account, reading from private tables, and visualizing data on maps all require an API key. CARTO provides API keys for education and nonprofit uses, among others. Request access atsupport@carto.com. API key access is also given throughGitHub’s Student Developer Pack.
Package: cartogeo-generator
CartogeoMap ImageGenerate an image of a map between two pointspython-mcartogeo.mapNH9506NO1090output.png
python-mcartogeo.mapNH9506NO1090output.png--25k

python-mcartogeo.mapNH0128NH1521output.png
python-mcartogeo.mapNH0128NH1520output.png--25k
python-mcartogeo.mapNH008282NH152198output.png

python-mcartogeo.mapNC0000NO0000output.png--250kMap Printoutpython-mcartogeo.pdfNH0128output.pdf
python-mcartogeo.pdfNH012278output.pdf
python-mcartogeo.pdfNH0128output.pdf--portrait--25k
python-mcartogeo.pdfNH012278output.pdf--portrait--25kMap Data PathMAP_DATA_PATH
Package: carton
make a self-extracting virtualenv from directories or URLs of packagesTo package up all files in a virtualenvs source directory (e.g.):python path/to/carton.py myproject project/src/*This will create a self-extracting file,myproject.py, that will unfold
a virtualenv with the specified packages setup for developmentThe sources may be directories, local or HTTP-accessible tarballs, or ordinary
files. Thesetup.py`s found in the `srcdirectory after extraction will be
run (viapython setup.py develop) in the order they are provided. This makes
it possible to have completely local dependencies (without touching the net)
by correctly specifying the source order.  If asetup.pyis overwritten from
a later source, it will not be rerun (known limitation).The extracted virtualenv will be created in the current directory and will have
the same name as provided initially (e.g.myproject) unless–envis
specified.Normally, the entire contents of source directories are compressed and
packaged as-is.  When running with the–packageflag, a source tarball is
produced viapython setup.py sdistif the directory contains a top-levelsetup.py.Since directories are compressed as-is, portable file-based VCS repositories,
such a mercurial and git, may be cartoned this way (though note that newer
repositories may not be backwards-compatible with older clients).
Package: cartoonart
Cartoon ArtCreatecartoonfrom image or video.CLI tools for creating nice cartoonimagesandvideo.InstallpipinstallcartoonartHow to use cartoonartCreate cartoon art from imagecartoonartimage--iimg/nature.jpeg
cartoonartimage--iimg/nature.jpeg--oimg/cartoon-nature.jpeg
cartoonartimage--iimg/shuttle.jpg--oimg/cartoon-shuttle.jpgYou can omit option--othen cartoon will be saved with prefixcartoon-.Create cartoon art from video cameracartoonartvideo
cartoonartvideo--ovideoTo stop video recording pressQkey.You can omit option--othen video will be saved asvideo-art.avi.Get helpcartoonart--help
cartoonartimage--helpInstallcartoonartCLI completioncartoonart--show-completion
cartoonart--install-completionCartoons galleryContributingCONTRIBUTINGStats
Package: cartooner
CartoonerThis tool converts your photo into a cartoon-like imageSamplesinstallpip install cartoonerhow to usefromcartoonerimportcartoonizeimportcv2importosimporttimeinput_file=...# input image file nameoutput_file=...# output image file nameimage=cv2.imread(input_file)output=cartoonize(image)cv2.imwrite(output_file,output)Dependencesnumpyscipyopencv-pythonpipinstall-rrequirement.txtHow it worksThis cartoonizer uses K-means algorithm to cluster the histogram of image.
The value K is auto selected by the method in thispaper.
Package: cartoonfight
Cartoon FightCartoon Fight is a 2D battle game to play against your friends
with your favorites cartoon characters.Install$ pip install cartoonfightCartoon Fight works with Python 3.6+.Toupdateit just run$ pip install --upgrade cartoonfight.PlayJust run$ cartoonfight.Game Controls :video_game:Player OneALeft,WJump,DRight,FAttackPlayer Two← Left ↑ Jump → RightCTRLAttackCreditsProgrammed byKilian Melcher :email:kilian.melcher@gmail.comFilipe Ramalho :email:filiperamalhodasilva@gmail.comArtwork byIsabella Lúcio :email:isabella.lucio1@gmail.com