Saravanan666/pypi-org huggingface dataset:
Package: py-lead-generation
Lead-GenerationThe updated version of my outdated dirty clumsy and having shockingly high amount of stars repository on PythonInstallationpipinstallpy-lead-generationPypi LinkORgitclonehttps://github.com/Madi-S/Lead-GenerationcdLead-Generation
pythonrun.pyQuickstartimportasynciofrompy_lead_generationimportGoogleMapsEngine,YelpEngineasyncdefmain()->None:q=input('Enter your search query: ').strip()or'Barbershop'addr=input('Enter the location you would like to search in: ').strip()\or'Paris'zoom=float(input('[Optional] Enter google maps zoom: ').strip()or12)engine=GoogleMapsEngine(q,addr,zoom)awaitengine.run()engine.save_to_csv()engine=YelpEngine('Pizza','Mexico, Pampanga, Philippines')awaitengine.run()engine.save_to_csv('pizza_leads.csv')if__name__=='__main__':asyncio.run(main())Current functionality- Parse Google Maps
- Parse Yelp
- Export collected data to a CSV fileExpectations of this project:- Parse Google Maps and Yelp for telephone number, email, address and other information by given keyword
- Somehow parse search results in Google Search for the same information using regex or other algorithm
- Export all parsed data to csv or excel
- For parsed emails send a message, which will be prevented from going to spam
- For parsed telephone numbers send an SMS, which will b prevented from going to spam as well
Package: pyleaf
pyleaf is the Python implementation of the Leaf system. The Leaf
system is a pipeline (AKA data flow or data analysis protocol)
management system that allows to design the pipeline as an ASCII-art
diagram through a language called LGL (Leaf Graph Language, seehttps://github.com/franapoli/lglc).Main Leaf features include:Thin, lightweight, code-independent Abstraction Layer.Data flow graph embedded directly into Python source code.Automatic creation and management of variables associated with node
outputs.Automatic persistent storage and retrieval of node outputs.Session persistence (i.e. run half project, reboot machine,
automatically start again from the last processed node).Lazy builds (avoid running nodes that are not necessary for the
build of a requested resource).Multiprocessing (independent nodes run in parallel).Enforcement of code version consistency between nodes
(i.e. automatically reprocess all nodes deriving from node A if node
A is found to be changed).Automatic time and space requirements statistics.Automatic publishing (producing hypertext with visual representation
of the protocol, processing statistics, link to node outputs, node
documentation and source code).
Package: pyleafarea
LeafAreaCalculatorUpdated.
ComputerVison and Machine Learning: Convolutional Neural Network to compute leaf areaThis project was a free lancing project for School of Biological Science at Washington State University.
The goal of the project was to detect number of pixels that would potentially consitute a leaf. These 'green' pixels fraction as compared to a known
quantity computes the area (cm^2). This constitues to a classification problem over image object.Steps:Train CNN model to learn various levels of green, red and arbitrary pixels. [Note any other color except green and red is of no particular
interest to us, hence classified as arbitrary.Break the image as list of pixels and classify them in a supervised training fashion. [Select pure green leaf images placed in 'green' folder, pure 'red' images in 'red' folder, etc]Compile and save the model that tests with an acceptable accuracy. [Accuracy obtained: 95 %].Knowing that the number of pixels in every image is 4 cm^2, we computed the leaf area as number of green pixels ~ number of red pixels [whose areas is known].The project was implemeneted using Python Keras/Tensorflow libraries and OpenCV/color packages.
A substantial advantage of this program was, due to the state of the art CNN machine learning algorithm used, leaf object with varied
intensities of green were classfied with supreme accuracy. The raw images were generated through different sources, scanner and DSLR camera,
but due to the algorithm logic, these differences were incorporated and computation did not result in loss of records.This algorithm has been successfully run on atleast 3500+ images and has helped the research lab save valuable time and energy
otherwise invested in manual efforts.
Package: pyleafpro
pyleafproMódulo para exemplificar construção de projetos python do curso pytoolsNesse curso é ensinado como contribuir com projetos de código abertolink para cursopython prosuportada versão 3 de pythonPara instalar:python3 -m venv .venvsource .venv/bin/activatepip install -r requirements-dev.txtPara conferir qualidade do código:flake8tópicos a serem abordados:
1.Git
2.virtualenv
3.Pip
Package: pyleague
PyleagueIndexOverviewRequirementsInstallationConfigurationTestsDeployment7.Getting started:OverviewPyleague is a cli tool that helps organizing competitions.
After providing pyleague with a list of the competition's participants
you will be able to get the matches for each day of the competition.RequirementsSystem requirementspython >= 3.9Package requirementsListed in pyproject.toml under '[tool.poetry.dependencies]'InstallationFor useFetch it from pippipinstallpyleagueFor developmentTo install package dependencies, installpoetry, then run the following command:poetryinstallTestsFrom root directory run:pytest pyleague/testsDeploymentUse poetrypoetry buildpoetry publishGetting startedTo try the app:Install itOn your terminal runpyleague initDefine your league participants as asked.Check the matches for todaypyleague todayUpdate the league to the next daypyleague nextpyleague today
Package: py-leap-api
TryLeap Python APIThe py_leap_api Python package provides a simple interface for interacting with the TryLeap service, a cloud-based platform for generating images using artificial intelligence.InstallationYou can install the py_leap_api package using pip:pipinstallpy_leap_apiGetting StartedFirst, you'll need to create an account on the TryLeap website and obtain an API key.Once you have an API key, you can use the TryLeap class to interact with the service. Here's a simple example that creates a model, uploads some images, and generates some images based on a prompt:frompy_leap_api.leapimportTryLeap# Create a TryLeap object with your API keyapi_key="your-api-key"leap=TryLeap(api=api_key)# Create a modelmodel=awaitleap.create_model("My Model")print(model)# add the model idleap.set_model(model=model["id"])# Upload some imagesurls=["https://example.com/image1.png","https://example.com/image2.png","https://example.com/image3.png",]awaitleap.upload_images_url(urls)# Train the modelqueue=awaitleap.training_model()print(queue)Ideally if you have a webhook url you can provide it to training_model in order to know when the training finished.
Otherwise you can fetch the status that return from the function.# Generate some imagesprompt="a cat sitting on a couch"response=awaitleap.generate_image(prompt,number_images=3)# Retrieve the output imagesoutput_images=awaitleap.output_images()LicenseThis library is licensed under the MIT License. See the LICENSE file for details.
Package: pyleapcard
pyleapcardA Python API for accessing your current card balance and stats for Ireland's public transportLeap Card. This is an unoffical API and the author/contributors are in no way connected to Leap Card, Transport for Ireland, or any other agency. The API provides methods to:Get your credit balance and card status informationGet a list of your recent trips & topupsFor an example of this in use, see myLeap Card BitBar pluginInstallationpip install pyleapcardUsageIt's very easy to use. Try the following to get your card status and current balance:frompyleapcardimport*frompprintimportpprintsession=LeapSession()session.try_login("<username>","<password>")overview=session.get_card_overview()pprint(vars(overview))returns:{'auto_topup':u'Not Enabled','balance':25.02,'card_label':u"<Card Label>",'card_num':u'<Card Number>','card_status':u'Unblocked','card_type':u'Adult','credit_status':u'Unblocked','expiry_date':u'09/12/2023 12:00:00 AM','issue_date':u'02/04/2012 12:00:00 AM'}Or to get your recent trips/topups add the following:events=session.get_events()foriteminevents:pprint(vars(item))returns:{'date':u'06/09/2017','event_type':u'Travel Credit Deduction','price':-3.52,'provider':u'Bus Eireann','time':u'11:45 AM','was_topup':False}{'date':u'06/09/2017','event_type':u'Travel Credit Top-Up','price':50.0,'provider':u'Leap Top-Up App','time':u'10:00 AM','was_topup':True}{'date':u'02/09/2017','event_type':u'Travel Credit Deduction','price':-3.52,'provider':u'Bus Eireann','time':u'12:16 PM','was_topup':False}Testspython ./tests/tests.pyContributingFork this repo, make some changes and create a new pull request!
Package: pyleapo
pyleapoAn unoffical Python API for accessing yourLeap Cardbalance, overview, and travel credit history. Underneath the hood, pyleapo usesScrapyto retrieve its data and therefore brings you an additional suite of options to utilise further if necessary.RequirementsPython 3.5.2+InstallationSimply:pipinstallpyleapoUsageThere are three modules to choose from, the samples below showcase each of them one by one.1. Card OverviewRetrieves a card's overview information such as the current balance and more.Codefrompyleapo.overviewimportget_card_overviewoverview=get_card_overview(username='',password='')print(overview)Output{'auto_topup':'...','card_expiry_date':'...','card_issue_date':'...','card_label':'...','card_number':'...','card_status':'...','card_type':'...','travel_credit_balance':'...','travel_credit_status':'...'}2. Card HistoryRetrieves a card's travel credit history as far as it goes back.Codefrompyleapo.historyimportget_card_historyhistory=get_card_history(username='',password='')print(history)Output[{'amount':'...','balance':'...','date':'...','source':'...','time':'...','transaction_type':'...'},...]3. Card Overview and HistoryRetrieves both the overview and history of a card all in one.Codefrompyleapo.aioimportget_card_overview_and_historyboth=get_card_overview_and_history(username='',password='')print(both)Output{'overview':{'auto_topup':'...','card_expiry_date':'...','card_issue_date':'...','card_label':'...','card_number':'...','card_status':'...','card_type':'...','travel_credit_balance':'...','travel_credit_status':'...'},'events':[{'amount':'...','balance':'...','date':'...','source':'...','time':'...','transaction_type':'...'},...]}
Package: pyleaps
PYLEAPSThis package wants to be a simple porting of the regsubset function from R.
UnlikeleapsinR, the package is not optimized yet, and requires extra work to improve code readability.
For now, I have implemented forward/backward/best subset selection for linear regression, building on top
of the excellentstatsmodelspackage.In addition, for now, the user needs to manually code the categorical variable contrasts. This will be fixed in the future.The package can be easily installed through pip. Check outhttps://pypi.org/project/pyleaps/for detailsTO INSTALLpip install pyleapsThe relevant dependencies should automatically get installed, in case they are not present in the environmentCOLLABORATIONAny help/collaboration is very welcome. Just let me know what kind of edits you propose and I will be very happy to discuss them.TO DOsThis section contains a list of future edits:Improve general code readabilityFigure out a way to speed up best subset section. So far, it is way slower than the R counterpart.
Package: pyleargist
Author:<olivier.grisel@ensta.org>Library to compute GIST global image descriptors to be used to compare pictures
based on their content (to be used global scene recognition and categorization).The GIST image descriptor theoritical definition can be found on A. Torralba’s
page:http://people.csail.mit.edu/torralba/code/spatialenvelope/The source code of the C implementation is included in thelear_gistsubfolder. Seehttp://lear.inrialpes.fr/softwarefor the original project
information.pyleargist is licensed under the GPL, the same license as the original C
project.InstallInstall libfftw3 with development headers (http://www.fftw.org), python dev
headers, gcc, the Python Imaging Library (PIL) and numpy.Build locally for testing:% python setup.py buid_ext -i
% export PYTHONPATH=`pwd`/srcBuild and install system wide:% python setup.py build
% sudo python setup.py installUsageHere is a sample session in  a python shell once the library is installed:>>> from PIL import Image
>>> import leargist

>>> im = Image.open('lear_gist/ar.ppm')
>>> descriptors = leargist.color_gist(im)

>>> descriptors.shape
(960,)

>>> descriptors.dtype
dtype('float32')

>>> descriptors[:4]
array([ 0.05786307,  0.19255637,  0.09331483,  0.06622448], dtype=float32)The GIST descriptors (fixed size, 960 by default) can then be used as an
euclidian space to cluster images based on their content.This dimension can then be reduced to a 32 or 64 bits semantic hash by using
Locality Sensitive Hashing, Spectral Hashing or Stacked Denoising Autoencoders.A sample implementation of picture semantic hashing with SDAs is showcased in
the libsgd library:http://code.oliviergrisel.name/libsgdChanges1.1.0: 2010/03/25 - fix segmentation fault bug, thx to S. Campion1.0.1: 2009/10/10 - added missing missing MANIFEST1.0.0: 2009/10/10 - initial release
Package: pyLearnAlgorithms
pyLearnAlgorithms - [latest version: 0.3.5]This package was developed as one of the results of a research project developed at the Federal University of Campina Grande.Getting StartedDependenciesYou need Python 3.6 or later to usepyLearnAlgorithms. You can find it atpython.org.You also need numpy, scipy and matplotlib packages. If you have pip, just run:pip install numpy
pip install scipy
pip install matplotlibInstallationinstall the package via PiP, use the following command:pip install pyLearnAlgorithmsUpdateTo update the package, use the following command via PIP:pip install --upgrade pyLearnAlgorithmsRemove packageTo remove the package, use the following command via PIP:pip uninstall pyLearnAlgorithmsFeatures- [x] Solving linear regression problems
- [x] Solving polynomial regression problems
- [x] Solving logistic regression problems
- [x] Neural network model using logistic regression
- [x] Open data on different formats
- [x] Split data into training, validation and testing
- [x] Several examples available for learning
- [x] Setup with package informations
- [x] License example
- [x] Package based on numpy, scipy and matplotlib
Package: pylearning
## Pylearning: python machine learning library[![license](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](https://github.com/amstuta/pylearning/blob/master/LICENSE.md)[![PyPI](https://img.shields.io/pypi/pyversions/pylearning.svg)]()Pylearning is a high-level machine learning package designed to easily prototypeand implement data analysis programs.The library includes the following algorithms:- Regression:- Decision tree regressor- Random forest regressor- Nearest neighbours regressor- Classification:- Decision tree classifier- Random forest classifier- Nearest neighbours classifier- Clustering:- K-means- DBSCAN (density-based clustering)The two random forests algorithms use multithreading to train the trees in aparallelized fashion.This package is compatible with Python3+.### Basic usageAll the algorithms available use the same simple interface described in theexamples below.```python# Basic regression example using a random forestfrom pylearning.ensembles import RandomForestRegressor# Load the training datasetfeatures, targets = ...rf = RandomForestRegressor(nb_trees=10, nb_samples=100, max_depth=20)rf.fit(features, targets)# Load a testing sampletest_feature, test_target = ...value_predicted = rf.predict(test_feature, test_target)``````python# Clustering example using DBSCAN algorithmimport matplotlib.pyplot as pltfrom pylearning.clustering import DBSCANfrom sklearn.datasets import make_circles# Load a dataset composed of two circlesdata = make_circles(n_samples=1000, noise=0.05, factor=0.3)[0]cl = DBSCAN(epsilon=0.2)cl.fit(data)labels_data = {i: ([],[]) for i in range(-1, 2)}for ex, label in zip(data, cl.labels):labels_data[label][0].append(ex[0])labels_data[label][1].append(ex[1])colors = ['g','b']for label, values in labels_data.items():if label == -1:plt.scatter(values[0], values[1], color='black')else:plt.scatter(values[0], values[1], color=colors[label], s=50)plt.show()```![Alt text](resources/dbscan.png?raw=true)A complete documentation of the API is available [here](https://pylearning.arthuramstutz.com/).### InstallationPylearning requires to have numpy installed. It can be installed simply using Pypy:```sh# for the stable versionpip3 install pylearning# for the latest versionpip3 install git+https://github.com/amstuta/pylearning.git```### Further improvementsThe core functionalities of the different algorithms areimplemented in this project, however there are many possible improvements:- gini criterion for splitting nodes (Decision trees)- pruning (Decision trees)- ability to split a node into an arbitrary number of child nodes (Decision trees)- optimizations to reduce time and memory consumption- better compatibility with pandas DataFrame- addition of new algorithms (density-based clustering, SVM, neural networks, ...)If you wish, you're welcome to participate in the project or to make suggestions !To do so, you can simply open an issue or fork the project and then create a pullrequest.
Package: pylearn-ml
PyLearnA simple library for machine learning topics.Explore the docs »Report Bug·Request FeatureAbout The ProjectPyLearn implements machine learning features from scratch.
It supports basic features of supervised and unsupervised learning.You cancreate neural networks with dense layers, different activation functions and loss functions,cluster your data without previously known classes,classify dataevaluate modelsand moreRead theDocumentationfor more information.(back to top)Built WithThe source code was built with Python, mainly using NumPy and Pandas.(back to top)RequirementsRequirements can be found underdocs/requirements.txt.(back to top)UsageImport the library:importpylearnasplMost models have afitand apredictfunction.Just create a model, train it and use it for predictions.model=pl.Model()model.fit(x_train,y_train)...model.predict(y_test)For details of usage, have a look at theexamplesfolder.Or read theDocumentation(back to top)ContributingIf you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestPlease follow theContributingguidelines.(back to top)LicenseDistributed under the MIT License. SeeLICENSEfor more information.(back to top)
Package: pylease
Pylease is a simple package that tends to ease the release process of a regular Python package. The aim of Pylease is to make it as
simple as possible by requiring as little as possible. For more details on using Pylease please see thedocumentation.Basic UsageStart using pylease by just navigating to you package root (the directory containingsetup.py) and simply use the command-line:$ pylease statusNow you will see basic information about your package, like name and version. Then take a try and do:$ pylease make --devThis will release the package with version ‘1.0.dev1’, i.e. update the version in setup.py. The release levels includemajor, minor, patch and dev.If you want to initiate a branch new project, perform this:$ pylease init my_projectThis will prepare and create all needed files and directories for your project skeleton.ExtensionsPylease also comes with extensions mechanisms. It includes some useful extensions that might be used in combination as well as anyone can
write extensions for Pylease to enhance it.GitGit extension provides functionality to automatically create a tag on the
git repository associated with the version, and commit the changes made to
thesetup.py.This may be achieved by simply adding--git-tagargument while calling
pylease:$ pylease make --minor --git-tagAfter making the release, you will additionally have a new commit
containing the setup.py update as well as a new tag pointing to that commit.PyPIPyPI extension provides an ability to automatically upload you package distribution toPyPiafter releasing your project. To enable this feature use the--pypicommand line option:$ pylease make --major --pypi
Package: pyleb128
pyleb128Powerful little-endian base-128 encoding/decoding library for Python 3.Supports the following types:Unsigned LEB128Signed LEB128Unsigned LEB128 +1 (ULEB128P1)NoteThe LEB classes all inherit fromintand have all the operations implemented. The type of the result from any int operation will always be the type of the lhs. If the lhs is an int, then the type is an int. If the lhs is a LEB type, then the resulting type is a LEB.Installingpython -m pip install -U pyleb128Example Usagefrompyleb128importuleb128,sleb128# unsignedprint(uleb128(0xffff).size)# 2print((uleb128(0xffff)*2).encoded)# b'\xfe\xff\x07'print(uleb128.decode(b'\xff\xff\x03'))# 65535print(uleb128.decode(b'\xff\xff\x03').encoded)# b'\xff\xff\x03'print(uleb128.decode(b'\xff\xff\x03',p1=True))# decode with as ULEB128P1# signedprint(sleb128.decode(b'\xf3\xff\xff\xff\x0f'))# -13print(uleb128.decode(b'\xf3\xff\xff\xff\x0f').encoded)# b'\xf3\xff\xff\xff\x0f'# can decode from a binary stream, too:importiostream=io.BytesIO(b'\xff\xff\x03')print(uleb128.decode_stream(stream,p1=True))
Package: pylebedev
PyLebedevPurposePyLebedev is a python package that storesLebedev quadraturecoefficients for integration over the unit sphere.InstallationAnacondaOpen Anaconda prompt and typeconda install -c ifilot pylebedevPyPiOpen a terminal and typepip install pylebedevUsagefrompylebedevimportPyLebedevimportnumpyasnpdefmain():"""Test Lebedev quadrature for probe function"""# build libraryleblib=PyLebedev()# exact answer to function "testfunc"exact=216.0*np.pi/35.0r,w=leblib.get_points_and_weights(9)integral=4.0*np.pi*np.sum(w*tfunc(r[:,0],r[:,1],r[:,2]))print('Integral:%fvs Exact:%f'%(integral,exact))deftfunc(x,y,z):"""Trial function to testAdapted from: https://cbeentjes.github.io/files/Ramblings/QuadratureSphere.pdfThis function has the exact result upon integration over a unit sphereof 216/35 * pi"""return1+x+y**2+x**2*y+x**4+y**5+x**2*y**2*z**2if__name__=='__main__':main()
Package: pyleetcode-cli
Leetcode CLIGet your Leetcode account into the terminal. Search for problems, solve them and submit.InstallationWindowspip install pyleetcode-cliLinuxsudo pip install pyleetcode-cliConfigurationFor this software to work you need to be logged into your Leetcode account. Your Leetcodesession_id(can be found in cookies) is required for client initialization.Chrome / Edgechrome://settings/cookies/detail?site=leetcode.comAfter you get yoursession_idyou can either paste it into the right place inconfig.yamlfile or use the CLI for the configuration:leet config session_id YOUR_SESSION_IDUsageLeet CLI

options:
  -h, --help            show this help message and exit
  -v, --version         show program's version number and exit

Commands:
  {config,stats,list,problem,today,submission,submit,check}
    config              Configure the CLI
    stats               Display statistics
    list                Display problem list
    problem             Display problem
    today               Display today's problem.
    submission          Download submission code
    submit              Submit code answer
    check               Check code answer on example testExample workflowYou can search for the problem in multiple ways: using lists, fetching question of the day, random question or using specific ID.Take problem1, show its contents in the terminal and create a file with the code snippet:leet problem 1 -fcNow try to solve the problem. After that you can check the code against example test case:leet test <filename>Then try to submit the solution and wait for the response:leet submit <filename>