Saravanan666/pypi-org huggingface dataset:
Package: python-emailahoy3
Python Email Ahoy 3A Python email utility that verifies existence of an email addressOverviewA Python email utility that verifies existence of an email address.
This package is based onthispackage which only run in Python 2.
It has been refactored to work in Python 3.How to installUse Pip (note that it works only for Python 3.6+ sicne it uses f-strings):pip3 install python-emailahoy3 --userHow to useUse the shorthand function for quick check:from emailahoy3 import verify_email_address
status =verify_email_address('test@example.com')
print(status)Codes are defined as follows:1. The email exists.0. The email does not exist.-1. The existence of the email could not be verified.You can also use the class for more control & more granular return status:from emailahoy3 import VerifyEmail
e = VerifyEmail()
status = e.verify_email_smtp(
                    email='test@example.com',
                    from_host='mydomain.com',
                    from_email='verify@mydomain.com'
                )
if e.was_found(status):
    print >> sys.stderr, "Found:", status
elif e.not_found(status):
    print >> sys.stderr, "Not Found:", status
else:
    print >> sys.stderr, "Unverifiable:", statusNotesNot all email servers will return the correct statusChecking an invalid email address returns within 1 secondChecking a valid email address returns within 4 seconds or moreRunning the testsTo run the tests against the current environment:python3 -m unittest discoverLicenseReleased under a (BSD) license.
Package: python-emailer
python-emailerWhat is it?python-emailer is a Python package that aids in sending of emails. It is a robust package which aims to cover every aspect of sending emails thereby, helping developers code less.Typical Usagefrompython_emailer.email_processingimportPyMailerlogin_details=['sender_email','password']email_sender=PyMailer('recipient_data.csv',login_details,subject='Job Application','Find attached my cv')email_sender.send_email(file_path='cv.pdf')Main FeaturesHere are some of the supported features of python-emailer:Checks and cleans common errors in email addresses like ( unexpected spaces, fullstops).Checks for valid email address syntaxReads email content from strings, .html files, or .txt filesReads recipient data from string, list, tuple, set, dictionary, .json, and .csv files.Auto detects the SMTP host of the provided sender email address.Attaches files to the email. Can also attach all files in a given directory. Can also display files(images) in the email.Auto detects the message type of the email(html or plain)Includes recipient's name in the email after the provided introductory string(i.e Hello <recipient_name>)Where to get itThe source code is hosted on Github:https://github.com/hilariie/python-emailerAnd can be installed from Python Package Index(PyPI)pip install python-emailerDependenciesThis package only makes use of python builtin packages.LicenseMITContributingContributions, bug reports and fixes, documentation improvements and enhancements, and ideas are all welcome.To contribute:Fork this repoClone your repogit clone <your repo>Make commit changesgit add <changed files>git commit -m "commit messagePush changesgit push ..Create a pull requestHow to useFile attachments:To attach files to an email, provide the path to the files to thefile_pathargument ofsend_emailFor acv.pdffile....send_email(file_path='C:\\email\\attachments\\cv.pdf')To attach multiple files, pass the directory instead...send_email(file_path='C:\\email\\attachments')To display images in email, make sure you have cid:<image_name> in your email content/message where you want to display the image.
An example is shown belowHello,<p>Belowistheorderofthemeetup</p><p><imgheight="auto"src="cid:image_test"style=".."width="100"/></p>pass in the exact cid value in the send_email methodsend_email(cid_img='image_test')Greeting:For multiple recipients (names and email addresses) where you wish to address them by names,simply pass the greeting string.send_email(greeting='Hello')email appears as:Hello <recipient_name>Email bodyRecipient data:Recipient data can be read from various data and file types such assets - recipient email addresseslists - recipient email addressestuples - recipient email addressesdictionaries - recipient email addresses, names, and ccstring - recipient email addresses.json files - recipient email addresses, names, and cc.csv files - recipient email addresses, names, and cc.csv files:csv files should be arranged in this order below.json files/dictionariesDictionaries should be in one of the two structures{names:[name1, name2, ...], emails:[email1, email2, ...], cc:[cc1, cc2, ...]}{name1:email1, name2:email2, ...}
Package: python-embedded-launcher
An other tool to make standalone Windows applications with Python.The launcher is a small C program that loads the Python DLL and callsPy_Mainwith itself as parameter, loading a zipped Python application
appended to the exe. It isolates the execution from the environment (e.g.
other Python installations on the same machine).Dependencies are installed with pip. There is no automatic detection or
scanning of source files. Instead,setup.py(with setuptools’install_requires) orrequirements.txtis used.Quick Startmake asetup.pyfor your application, usescriptsand/orentry_pointsforconsole_scriptsrunpython setup.py bdist_launcherDone. See result indist/launcher*.DocumentationSeedocumentation/index.rstfor more details.
Package: python-emec-api
Python - EMEC APIThis package is designed to make it easy to use theEMEC Datain Python. This application obtains data through scrapping.DocumentationIn development...Author@natanrmaiaInstalationpipinstallpython-emec-apiReport or RequestBug ReportFeature requestReport a security vulnerabilityOther questionsEmail - contato@natanael.dev.br
Package: python-emit
EmitA Python library for understated tracing and structured logging.TL;DR# This is the big idea. Now let's use it.defemit(obj):returnobj.__emit__()Loggingfromemitimportemit,Info,Warningdeffrobulate_the_quartzle():# This works like you expect, no more logger = logging.getLogger(__name__).# just emit and the log will originate from the right place.emit(Info("Frobulating the quartzle"))ifnotQuartzle.is_polarized():emit(Warning("Quartzle isn't polarized, results may be different than expected."))Structured Loggingfromemitimportemit,Contextdefpush_noins():emit(Info("Noins updated."))defshuffle_lorpizoids():emit(Context(current_user="Harry Styles"))# The log emitted from this code will include the current_user context.push_noins()Say No To Passing Around Loggers Just To Bind Values# In `structlog`log=log.bind(key=value)# In `emit`emit(Context(key=value))
Package: python-eml
emlThis Python package contains dataclasses generated usingxsdatafor theEcological Metadata Language (EML)standard as well its GBIF profile.Quick startfromxsdata.formats.dataclass.serializersimportXmlSerializerfromxsdata.formats.dataclass.serializers.configimportSerializerConfigfromeml.gbif_1_1importAgentType,Eml,Dataset,IndividualName,IntellectualRights,KeywordSet,Para,Ulink,Abstractdoc=Eml(package_id="http://ipt.vliz.be/kmfri/resource?id=vegetation_gazi_bay_kenya_1987/v1.0",system="http://gbif.org",lang="eng",dataset=Dataset(title="Test dataset",abstract=Abstract([Para(["Suspendisse imperdiet imperdiet leo, at eleifend nisi rutrum eget. Donec aliquam mollis risus, feugiat laoreet nulla facilisis vel. Fusce viverra magna ante, ut lobortis sapien convallis ut. Nulla facilisi. Cras at tellus leo. Suspendisse eget blandit tellus. Duis auctor turpis eros. Nullam convallis ligula eleifend volutpat aliquam. Donec cursus mattis viverra. Nunc ac lorem vel lectus malesuada bibendum. Vestibulum non dolor quis enim auctor consectetur in a augue. Maecenas sodales ullamcorper quam."])]),alternate_identifier="http://ipt.vliz.be/kmfri/resource?id=vegetation_gazi_bay_kenya_1987/v1.0",creator=AgentType(individual_name=[IndividualName("John","Doe")]),keyword_set=KeywordSet(keyword=["test keyword"]),intellectual_rights=IntellectualRights(para=Para(["This work is licensed under a ",Ulink(url="http://creativecommons.org/licenses/by/4.0/legalcode",content=["Creative Commons Attribution (CC-BY) 4.0 License"]),"."])),))config=SerializerConfig(pretty_print=True)serializer=XmlSerializer(config=config)print(serializer.render(doc))
Package: python-eml-parser
InsightConnect Integrations Email ParserTooling for parse emails inRapid7 InsightConnectplugins.Installationpip install python-eml-parserUseSimple!Pythonfrom python-eml-parser.email_parser import EmailParser
from email import message_from_string


email_parser = EmailParser()
email = email_parser.make_email_from_raw(
    self.log, message_from_string(raw_email), mailbox_id
)ContributionsContributions are welcome! This project utilizesblackandpre-commitfor handling code
style. Simply follow the instructions for installing pre-commit and
runpre-commit installin the repository after cloning and you will
be on your way to contributing!Changelog2.0.1 - Adding in a default of empty string if there is noFromsection in an email2.0.0 - MD5, SHA1, and SHA256 Indicators for Base64 Content are now hashes of the decoded Base64 Content1.0.0 - Initial release
Package: python-emotion
Python bindings for Emotion, part of Enlightenment Foundation Libraries.Emotion is an Evas smart-object library providing video
capabilities. Emotion leverages libxine 1.0 or gstreamer 0.10 and
integrates seemlessly with the rest of the EFL. Because its based on
libxine or gstreamer, any format that it supports (Theora, DiVX,
MPEG2, etc) is avalible using Emotion.
Package: python-engineering
Python EngineeringThis package contains Python functions for engineering applications.python-engineering bundles a large amount of knowledge and provides it to end users through extensively documented functions. The aim of the package is as follows:Improve correctness through unit-tested functions with parameter validationRaise awareness on underlying test data and theories supporting engineering correlations and design formulaePromoting development of open-source engineering software by the worldwide community of engineerspython-engineering is developed using a set of 10 Golden rules which are reflected in the python-engineering function
architecture and should also be followed by any contributors to the project.Installation requirementspython-engineering is written for Python 3.x. Downloading Anaconda3 is recommended for users not familiar with Python development.Copyright (c) 2016, Bruno Stuyts
All rights reserved.Licensepython-engineering is provided under a Creative Commons Attribution-ShareAlike 4.0 International Public License. Please check the license terms below and in the license file.Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the {organization} nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Package: python-engineio-client
Python implementation of the engine.io client.Design & goalsThis implementation is inspired by the JavaScriptengine.io-clientimplementation.Protocol parser is copied in parts and at least largely inspired from the
packagepython-engineiowritten byMiguel Grinberg.This engine.io client is usingGeventfor now. This is not a strict design
choice but a simplification for this first implementaion. Other asynchronous
frameworks are welcome for future versions.Examplefrom engineio_client.client import Client

import gevent
import gevent.monkey
gevent.monkey.patch_all()

eio = Client('localhost', 8000)

@eio.on('message')
def on_message(message):
    print message
    eio.close()

@eio.on('open')
def on_open():
    eio.send("Hello")

eio.open()
gevent.wait()LinksAnother engine.io/socket.io client:socketIO_client
Package: python-engineio-yas
python-engineioPython implementation of theEngine.IO_ realtime client and server.SponsorsThe following organizations are funding this project:Socket.IOAdd your company here!Many individual sponsors also support this project through small ongoing contributions. Why notjoin them?ResourcesDocumentationPyPIChange LogQuestions? See thequestionsothers have asked on Stack Overflow, oraskyour own question.
Package: python-enigma
python-enigma: Engima Machines, But With PythonThis project introduces a package, python_enigma, with anenigmamodule which can be imported and used to include Enigma-Machine-like encryption to your python project. Also included is a simplistic "Hello World" proof of concept, a basic catalogue of rotors in the jason format expected (catalogue.json), and a convenience script for preparing the catalogue from a csv.Security NoticeIn the age of gigahertz pocket computing, the Enigma cipher is useful as a point of curiosity only. None of the original security flaws with the Enigma machine as patented have been corrected.Historical Accuracy NoticeWhile pains were taken to ensure the interoperability of this emulator and the actual enigma machine, nothing about the module enforces historical accuracy in terms of the use of particular parts or settings, or the "tidying" features of the operator.In particular, this model allows for an aribtrary number of wheels to be used, some of which were not historically used together. All wheels obey an M3/M4-style "double stepping" movement pattern. The smoother gearbox stepping patterns of some later models are not emulated.Making useThe principle way to use the Enigma module in your scripts is to import and invoke the Enigma class. For convenience, you can read in the string "default" as the catalog list to use the stock catalog included in the module.The Enigma class accepts the following arguments on initialization:catalog: a dictionary of rotor bindings, or the string "default" to use the stock bindings included in the module.stecker: A space-seperated string of bindings to use for the steckerboard settings. Ex, "AB CD" means that stecker cables are set between A and B, and C and D.rotors: a list of tuples showing the rotor name from the catalog and the desired ringstellung letter setting, ex[("III", "D"),]. Any number of rotors may be used, including duplicates.reflector: a string indicating the name of the rotor from the rotor catalogue which you would like to use for the reflector, ex 'Reflector B'.operator: if True, the operator class will be used. This strips unprintable characters from the message and cuts the message into 5-character chunks.word_length: overrides the length of the words used by the operator.stator: accepts "military" or "civilian", to imitate either the direct encoding of the military version of the device or the QWERTZ encoding used in the civilian model.Use of the Enigma class provides a variety of convenience methods:set_wheels: accepts a string of wheel positions (as read left to right) and applies them to be the message setting. Should be called before every parse call.set_stecker: if desirable, one could override the steckerboard settings after instantiating the entire machine.parse: parses the string provided and returns that message as though it were processed through an actual Enigma Machine.
Package: pythonenv
python_shebang Description==========================[![Build Status](https://travis-ci.org/yahoo/python_shebang.svg?branch=master)](https://travis-ci.org/yahoo/python_shebang)This package provides a command that can be run from /usr/bin/env on theshebang line of a script that will find an appropriate python interpreterto run it.Unlike plain /usr/bin/env this script allows specifying the version of pythonand python modules that are required.Supported Operating Systems===========================This script is designed to operate on Unix operating systems.  It is of novalue on Windows which does not use shebang.Dependencies============python_shebang is written to be able to run under any python version 2.6 orhigher using only modules in the python standard library.Examples========Here is a shebang line that will run the script with a python2.6 interpreterthat has both the foo and bar modules:```#!/usr/bin/env python_shebang version:2.6 module:foo module:bar```This shebang line will run the script with a python 3 interpreter that hasthe paramiko module:```#!/usr/bin/env python_shebang version:3 module:paramiko```Running the command directly will give a python shell that meets therequirements (the asyncio module was added in python 3.4):```$ python_shebang module:asyncioPython 3.4.0 (v3.4.0:04f714765c13, Mar 15 2014, 23:02:41)[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwinType "help", "copyright", "credits" or "license" for more information.>>>```If a compatible interpreter cannot be found it will generate an exception (theasyncio module was added in python 3.4)```$ python_shebang module:asyncio version:3.3Traceback (most recent call last):File "/usr/bin/python_shebang", line 173, in <module>version, modules, python_interpreters=python_interpretersFile "/usr/bin/python_shebang", line 139, in __search_for_interpretersraise PythonNotFound('No usable python interpreters found')__main__.PythonNotFound: No usable python interpreters found```
Package: python-envoy-protobuf-installer
envoy-proto-builderBuilds and installs Envoy protocol buffers and the following
dependencies:data-plane-apigoogleapisprotoc-gen-validateopencensus-protoHow it worksClones the Envoy repository and associated dependencies to a temporary
location. Builds the proto files into virtual Python module and installs
the module with pip. The protobuf files are available inenvoy_proto.Installationpip installl envoy-proto-builderUsageRunning with no arguments will install the Envoy files from the master branch.usage: envoy-protobuf-builder [-h] [--version VERSION] [--src-dir SRC_DIR] [--no-clone]

optional arguments:
  -h, --help         show this help message and exit
  --version VERSION  The Envoy version to build. Defaults to master.
  --src-dir SRC_DIR  The directory to clone the repositories to. If not specified a temporary
                     location is used.
  --no-clone         Build the files with cloning the repositories.Code Samplefrom.commonimportmake_anyfromenvoy_proto.envoy.config.filter.accesslog.v2.accesslog_pb2importAccessLogfromenvoy_proto.envoy.config.accesslog.v2.file_pb2importFileAccessLogfromenvoy_proto.envoy.api.v2.core.config_source_pb2importConfigSourcefromenvoy_proto.envoy.api.v2.listener.listener_pb2import(Filter,FilterChain,)fromenvoy_proto.envoy.config.filter.network.http_connection_manager.v2.http_connection_manager_pb2import(HttpConnectionManager,HttpFilter,Rds,)FilterChain(filters=[Filter(name='envoy.http_connection_manager',typed_config=make_any(HttpConnectionManager(stat_prefix='ingress_http',rds=Rds(route_config_name='local_route',config_source=ConfigSource(path='/etc/envoy/routes.yaml',)),http_filters=[HttpFilter(name='envoy.router')],access_log=[AccessLog(name='envoy.file_access_log',typed_config=make_any(FileAccessLog(format='''\%REQ(:METHOD)% %REQ(:AUTHORITY)%%REQ(X-ENVOY-ORIGINAL-PATH?:PATH)% -> %UPSTREAM_CLUSTER% %REQ(:PATH)% %RESPONSE_CODE% %RESPONSE_FLAGS%\n''',path='/dev/stdout',)))])))])History0.1.0 (2019-12-05)First release on PyPI.
Package: python-env-starter
Getting your python repository setup for other developers to work on can be tedious and time consuming.  Use this small but handy utility to make setting up your python projects “mad easy” for other developers.Tons of thanks to @kennethreitz and @dasJ for making [autoenv](https://github.com/kennethreitz/autoenv) :)
Also thanks to @bkuberek for showing me how to write CLIs for applications!  👍Feel free to leave or send any feedback, always looking for ways to improve disWhat does it do??This script will create a few essential files in your repository:.envThis file is used by autoenv to automatically switch to your python virtualenv and run any generic shell commands
(such as modifying your $PATH or $BIN, adding aliases, etc.) whenever youcdinto your project directory.
Feel free to set your own common environment variables, aliases, functions, etc. in here!setup.shThis file allows developers who clone your repository to easily install OS-level dependencies.
Add your ownapt-getandbrewdependencies to this..gitignoreThis will add or update your.gitignoreto include the virtual env and compiled python files.  You don’t wanna source
control those!How do I do it??It’s easy peasy!  Just runInstallationsudopipinstallpython-env-starterRunning itpython-envsetup./setup.shsource~/.bashrcYou should now see the new files,.env,setup.sh, and.gitignorethen just commit the new files to your own repo :)
Package: python-envtools
Useful environment toolchain for pythonoverride_environmentContext Processor that overrides environment vars.>>> @override_environment(DEBUG=False, FOO="Bar")
>>> def foo():
>>>     print(os.getenv("FOO"))
>>>     return os.getenv("DEBUG")
>>> foo()
FOO
"DEBUG">>> with override_environment(DEBUG="False", FOO="Bar"):
>>>     print(os.getenv("FOO"))
>>>     os.getenv("DEBUG")
FOO
"DEBUG"configure_loggingWrap aconfigDictinside configure_logging, then logging level could be controlled by environment variablesLOGGING = configure_logging({
    "loggers": {
        "module": {
            "handlers": ["console"],
            "level": "INFO",
        },
    }
})For this example, environment variable must be set asLOGGING_LEVEL_module=DEBUG.get_envSimilar toos.getenv()but evaluates string content (default) into simple python types.>>> os.environ['FOO'] = "1"
>>> os.getenv('FOO')
"1"
>>> get_env('FOO')
1

>>> os.environ['FOO'] = "bar"
>>> get_env('FOO')
"bar"

>>> os.environ['FOO'] = "True"
>>> os.getenv('FOO')
"True"
>>> get_env('FOO')
True

>>> os.environ['FOO'] = "[1,2,3]"
>>> os.getenv('FOO')
"[1,2,3]"
>>> get_env('FOO')
[1, 2, 3]it works for list, tuples, dictionaries, numbers, booleans and strings. And is safe!