Saravanan666/pypi-org huggingface dataset:
Package: python-editor-hotoffthehamster
python-editorrevival fork fordob(becausepython-editorhas not
been releasedin many years).Original READMEpython-editoris a library that provides theeditormodule for
programmatically interfacing with your system’s $EDITOR.Examplesimporteditorcommit_msg=editor.edit(contents=b"# Enter commit message here")Opens an editor, prefilled with the contents,# Enter commit message here.
When the editor is closed, returns the contents (bytes) in variablecommit_msg.
Note that the argument tocontentsneeds to be a bytes object on Python 3.editor.edit(file="README.txt")OpensREADME.txtin an editor.  Changes are saved in place.  If there is
acontentsargument then the file contents will be overwritten.editor.edit(...,use_tty=True)Opens the editor in a TTY.  This is usually done in programs which output is
piped to other programs.  In this case the TTY is used as the editor’s stdout,
allowing interactive usage.How it Workseditorfirst looks for the${EDITOR}environment variable.  If set, it uses
the value as-is, without fallbacks.If no $EDITOR is set, editor will search through a list of known editors, and
use the first one that exists on the system.For example, on Linux,editorwill look for the following editors in order:vimemacsnanoWhen callingeditor.edit, an editor will be opened in a subprocess, inheriting
the parent process’s stdin, stdout.
Package: python-edje
Python bindings for Edje, part of Enlightenment Foundation Libraries.Edje is a complex graphical design & layout library, designed to be
used with “Evas” canvas system, also part of EFL.It doesn’t pretend to do containering and regular layout like a widget
set. For the purposes of Enlightenment 0.17, Edje should serve all the
purposes of creating visual elements (borders of windows, scrollbars,
etc.) and allow the designer the ability to animate, layout and
control the look and feel of any program using Edje as its basic GUI
constructor. This library allows for multiple collections of layouts
in one file, sharing the same image database and thus allowing a whole
theme to be conveneintly packaged into 1 file and shipped around.Edje separates the layout and behavior logic. Edje files ship with an
image database, used by all the parts in all the collections to source
graphical data. It has a directory of logical part names pointing to
the part collection entry ID in the file (thus allowing for multiple
logical names to point to the same part collection, allowing for the
sharing of data betwene display elements). Each part collection
consists of a list of visual parts, as well as a list of programs. A
program is a conditionally run program that if a particular event
occurs (a button is pressed, a mouse enters or leaves a part) will
trigger an action that may affect other parts. In this way a part
collection can be “programmed” via its file as to hilight buttons when
the mouse passes over them or show hidden parts when a button is
clicked somewhere etc. The actions performed in changing from one
state to another ar also allowed to transition over a period of time,
allowing animation.This separation and simplistic event driven style of programming can
produce almost any look and feel one could want for basic visual
elements. Anything more complex is likely the domain of an application
or widget set that may use Edje as a convenient way of being able to
configure parts of the display.Edje files may contain small scripts written in Embryo (a variant of
C, originally called Small, later renamed to PAWN).
Package: python-eeml
Authors:peter.vizi@gmail.comIntorductionThis is a python package for generatingeemldocuments.InstallationWith administrative privileges run:sudo python setup.py installWithout root access:python setup.py install --prefix=~/
PTYHONPATH="~/lib/python2.7/site-packages" python example/simple_example.pyExampleAn example python script for publishing measurement data:import eeml
import eeml.datastream
import eeml.unit
import serial

# parameters
API_KEY = 'YOUR PERSONAL API KEY'
API_URL = 'YOUR PERSONAL API URL, LIKE /api/1275.xml'

serial = serial.Serial('/dev/ttyUSB0', 9600)
readings = serial.readline().strip().split(' ') # the readings are separated by spaces
pac = eeml.datastream.Cosm(API_URL, API_KEY)
pac.update([eeml.Data(0, readings[0], unit=eeml.unit.Celsius()), eeml.Data(1, readings[1], unit=eeml.unit.RH())])
pac.put()Other examples can be found in the example folder.Requirementspython-xml
Package: python-eetlijst
Python-eetlijstUnofficial Python API for interfacing with Eetlijst.nl, a Dutch website used by
students to manage dinner status and expenses.Current features include:List all residentsGet the name of the listGet or set the noticeboardGet or set the dinner statusInstallationTo install this module, runpip install python-eetlijstto install from Pip.
If you prefer to install the latest version from Github, usepip install git+https://github.com/basilfx/python-eetlijst.ExamplesThree examples are included in theexamples/folder. The purpose is to
demonstrate some functionality.dinner.pyPrint or set the current dinner status, in a terminal window. Run it withpython dinner.py <username> <password> get|set.It shall print something similar to this, when getting the current status:Dinner status for 2014-03-30. The deadline is 16:00:00, and has passed.

In total, 4 people (including guests) will attend diner.

Unknown1 | Unknown2 | Unknown3 | Unknown4 | Unknown5
   C     |  D + 2   |    X     |    X     |    ?

X = No, C = Cook, D = Dinner, ? = Unknownnoticeboard.pyView or change the current noticeboard. Run it withpython noticeboard.py <username> <password> get|set.session.pyGiven a session id, print the name of the Eetlijst list. Run it withpython session.py <session_id>ContributingSee theCONTRIBUTING.mdfile.TestsCurrently, a minimal set of tests have been written. These tests only verify
the 'scraping' functionality and correct sesision handling, by faking
responses. However, they do not test any submit functionality, since it would
require an active connection with Eetlijst.nl during the tests.To run the tests, please clone this repository and runpoetry run pytest.DocumentationThis is future work :-)For now, please look at the source code, the tests and the examples.LicenseSee theLICENSE.mdfile (GPLv3 license). You may change the
code freely, but any change must be made available to the public.DisclaimerUse this library at your own risk. I cannot be held responsible for any
damages.This page and its content is not affiliated with Eetlijst.nl.
Package: pythonegardia
python-egardiaPython library to interface with Egardia / Woonveilig alarm. Tested withWV-1716,GATE-01,GATE-02,GATE-03andGATE-04version of Egardia / Woonveilig. Other versions might work, but unsure. Originally written for integration withHome Assistantit can also by used to integrate with these alarms in other solutions.Note on GATE-02There seem to be multiple versions of software running on GATE-02 devices; we have received reports from GATE-02 users who successfully run this package in GATE-02 mode. Others have reported they needed to specify GATE-03 as their version to integrate their GATE-02.Egardiadevice is the representation of the alarm control panel and the Egardiaserver can be used to handle alarm status changes including triggering. Test files are included for both device and server.EgardiaDeviceThis script talks to the Egardia alarm control panel and can read and set its status. Note that if the alarm is triggered the state is not published through the interface available to this script. To be able to respond to alarm triggers, set up the Egardia Server (see below). For testing purposes have a look at thetest_egardiadevice.pyscript. It's usage:test_egardiadevice.py[-h]hostportusernamepasswordversionFor example:python test_egardiadevice.py 192.168.1.X 80 user pass GATE-02.EgardiaServerThis script captures codes generated by the Egardia alarm control panel after it was set up to forward the codes to the machine running the script (see the Home Assistant docs: advanced configuration, step 1 to 3).usage:egardiaserver.py[-h][-PPORT]RuntheEgardiaServer

optionalarguments:-h,--helpshowthishelpmessageandexit-PPORT,--portPORTtheportnumbertoruntheserveron(defaultsto52010)--hostHOSTThehosttoruntheserveron(defaultsto'',whichislocalhost).SpecifythistheIPaddressofyourmachineifyouarehavingissuesreceivingmessages.The test script for the EgardiaServer istest_egardiaserver.pywhich tests if theegardiaserveryou are running is accessible.
Package: python-elastic-logstash
python-elastic-logstashLogstash dynamically ingests, transforms, and ships your data regardless of format or complexity. Derive structure from unstructured data with grok, decipher geo coordinates from IP addresses, anonymize or exclude sensitive fields, and ease overall processing.InstallationUsing pip:pip install python-elastic-logstashFeaturesSends Python logs in elasticsearch.Works with Python Django.Stop tolerance capability.Overwrite index from custom fields.If any issues please submit issues inhttps://github.com/washim/python-elastic-logstash/issuesUsageFor example:import logging
import sys
from python_elastic_logstash import ElasticHandler, ElasticFormatter

"""
Provide logger name simple without any special character
Logger name will become as Elastic Search Index
"""
logger = logging.getLogger('python-elastic-logstash')
logger.setLevel(logging.DEBUG)

elasticsearch_endpoint = 'http://localhost:9200' # No trailing slash

elastic_handler = ElasticHandler(elasticsearch_endpoint, 'dev')  # Second argument is optional
elastic_handler.setFormatter(ElasticFormatter())

logger.addHandler(elastic_handler)

# Extra is optional.
extra = {
    'elastic_fields': {
        'version': 'python version: ' + repr(sys.version_info)
    }
}

logger.debug("Python elastic logstash configured", extra=extra)Kibana Create Index PageKibana Discover PageUsing DjangoModify your settings.pyExample:LOGGING = {
    ...
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'elastic_handler': {
            'level': 'DEBUG',
            'class': 'python_elastic_logstash.ElasticHandler',
            'url': 'http://localhost:9200'
        },
        'console': {
            'class': 'logging.StreamHandler'
        },
    },
    'root': {
        'handlers': ['console'],
        'level': 'WARNING',
    },
    'loggers': {
        'django.request': {
            'handlers': ['elastic_handler'],
            'level': 'DEBUG',
            'propagate': True,
        },
        'python-elastic-logstash': {
            'handlers': ['elastic_handler'],
            'level': 'DEBUG',
            'propagate': True,
        },
    }
    ...
}
Package: python-elasticsearch-logging
elasticsearch-logging-handlerThis is a minimalistic Elasticsearch logging handler for python. This handler uses only url as an authentication method. For more robust authentication considerCMRESHandler.Package on PyPI -https://pypi.org/project/elasticsearch-logging-handler/Parameters forElasticHandler:NameTypeRequiredDefaultDescriptionExamplehoststrTrue-Url for Elasticsearch cluster. Currently, this handler support only basic authentication through providing user and password in the url.https://user:password@my-cluster.es:9200,https://my-cluster.es:9200indexstrTrue-Name of the Index to write in.preprocessing-logslevelintFalse0 (NOTSET)Minimal logging level for the handler. Handler will only process messages with level larger than this parameter.20, logging.WARNINGbatch_sizeintFalse1000Size of the buffer that stores logs before sending to Elasticsearch. If buffer is full, send batch immediately, without waiting for theflush_period2000 - send batches of maximum size 2000flush_periodfloatFalse1.0Period during which handler will accumulate logs into batch before sending it ot the cluster.10.0 - wait 10 seconds before sendingtimezonestrFalseNoneTimezone for which to transform @timestamp for the record.'Europe/Amsterdam', 'Australia/Sydney'ElasticHandleris nonblocking, meaning any logging call e.g.logging.exceptionwill not block calling thread. which is useful in the case of high logging load.Buildpoetry build -f wheelUseslogging.ini file[loggers]
keys = root

[handlers]
keys = file, console, elasticsearch

[formatters]
keys = default

[logger_root]
level = DEBUG
handlers = file, console, elasticsearch

[handler_console]
class = StreamHandler
level = DEBUG
formatter = default
args = (sys.stdout,)

[handler_file]
class = handlers.RotatingFileHandler
level = DEBUG
formatter = default
args = ("service.log","a",10000000,10,"utf-8")
;args = [filename,mode,maxBytes,backupCount,encoding}

[handler_elasticsearch]
class = python_elasticsearch_logging.ElasticHandler
args = ('http://elastic:changeme@localhost:9200','pylogger')
level = DEBUG
formatter = default

[formatter_default]
format = %(asctime)s - %(name)s-%(threadName)-10s-%(levelname)s - %(message)s
datefmt =
class = logging.Formatter
Package: python-electricity
python-electricityTariff Periods for electricity billingAvailable Operators:PortugalOperatorsEDPSimplesBi-horário - ciclo diárioBi-horário - ciclo semanalTri-horário - ciclo diárioTri-horário - ciclo semanalGalpSimplesBi-horário - ciclo diárioBi-horário - ciclo semanalIberdrolaCasaCasa Noite - ciclo diárioCasa Noite - ciclo semanalGoldEnergySimplesBi-horário - ciclo diárioBi-horário - ciclo semanalAvailable TariffsNormalPontaCheiasVazioVazio NormalSuper VazioStatusCurrently only Portuguese operators EDP, Galp, Iberdrola and GoldEnergy are available.Pull RequestsPull requests are welcomed and supported! Go ahead add your Country/Operator
Package: python-electron
python-electronThis is a very simple Python library to interface with the Electron-Packager command line tool.Key conceptsInteract with the Electron-Packager directly from PythonEnables building and archiving Electron applications from your Python codeUsageExample:import electron

application = electron.App(
    APPLICATION_NAME,
    APPLICATION_FOLDER
)
application.build('android') # or any installed platform
application.archive('ios') # or any installed platform
Package: python-elemental
ElementalPython Client for Elemental On-Premises AppliancesRun TestsBefore running tests locally, installtoxandpoetry.pipx install tox
pipx install poetryRun tests usingmake testTo run lint, usemake lintRelease Updated VersionUse the Github UI tocreate a new release, the tag needs
to follow the semver format0.0.0. After the new release is created, a Github workflow will build and publish the
new python package to PyPI automatically.
Package: python-elementary
PYTHON BINDINGS FOR ELEMENTARYREQUIREMENTSElementary >= 1.7.0Evas >= 1.7.0        (indirect, Elementary dependency)Ecore >= 1.7.0       (indirect, Elementary dependency)Python-Evas >= 1.7.0Cython >= 0.16       (not required with release tarballs)Python >= 2.7        (tested version, may work with older or newer)BUILDING AND INSTALLINGThis package uses automake, so execute:Build:./configure --prefix=/usr
make allInstall:make installIf you wish to install at alternative locations, then make sure to
configure your PYTHONPATH to be able to access this location!If you have Cython dependencies that are installed in alternative
locations and want Cython to find them, please specify CYTHONFLAGS
variable to ./configure.The discovery of dependencies is done with pkg-config, thus all your
packages must be properly accessible with such tool. Ensure your
PKG_CONFIG_PATH and PKG_CONFIG_LIBDIR (cross-compiles) are configured!When cross-compiling, if your target’s Python headers differ from your
host’s headers, specify PYTHON_INCLUDES variable containing the
directory of the correct version of Python.h!
Package: python-elementstx
This Python3 module implements support for Elements transactions.It builds on top, and is intended to be used along with python-bitcointx library.Requirementspython-bitcointx(version >= 1.0.0)secp256k1-zkpConfigure parameters forsecp256k1-zkp:./configure --enable-experimental \
                --enable-module-generator \
                --enable-module-rangeproof \
                --enable-module-surjectionproof \
                --enable-module-ecdh \
                --enable-module-recoveryUsage:With contextual switch to Elements parameters:importosimportelementstxfrombitcointximportChainParams,get_current_chain_paramsfrombitcointx.walletimportCCoinKey,CCoinExtKey,CCoinAddress,P2PKHCoinAddresswithChainParams('elements'):k=CCoinExtKey.from_seed(os.urandom(32))a=P2PKHCoinAddress.from_pubkey(k.derive_path("m/0'/0'/1").pub)print('example{}address:{}'.format(get_current_chain_params().name,a))assertCCoinAddress(str(a))==aWith global switch to Elements parameters:fromelementstximportElementsParamsfrombitcointximportselect_chain_paramsselect_chain_params('elements')# or, using the chain params class directlyselect_chain_params(ElementsParams)# To switch to Liquid Network parameters:select_chain_params('elements/liquidv1')Without the switch of chain parameters:fromelementstx.coreimportCElementsTransactiontransaction_data=read_tx_data()tx=CElementsTransaction.deserialze(transaction_data)print("Number of txout witnesses:",len(tx.wit.vtxoutwit))Example CodeSeeexamples/directory.
Package: python-elf-wrapper
Elf wrapperThis tool use thepyelftoolsto parse the elf file, and provide a interface
for user to get the global variable address informations.InstallationInstall use pip.$pipinstallpython_elf_wrapperHow to use itfromelf_addr_dictimportElfAddrObjelf=ElfAddrObj(r"example/test.elf")var_addr=elf.get_var_addrs('TestStructVar1')print(var_addr)enum_info=self.get_enum_info('TestEnumAType')Supported variable typesstructurestructure arraystructure array filedarrayTodosto add support for bit filed membersLicenseMIT
Package: python-eloqua-wrapper
python-eloqua-wrapperThis outlines the current behavior and use cases of the API via an example.Functionality includes creating, updating, or deleting Custom Data Object records in Eloqua, and
creating, retrieving, or deleting Contacts in Eloqua.Example OutlineLet's say we have a CDO with ID# 12345, and a record with these field values:Record ID#369789business_email:bob@bobbyworld.comfirst_last_name: bob_wilbertzip_code: 32123job_title: Nannygoat HerderWe would like to update him in our CDO with the following:zip_code: 22667job_title: Alligator WranglerHow do we upload changes via our lovely api wrapper?Step 1: What you need to upload data to EloquaTo push a given record with the basic CdoRecord class, you will need:the CDO IDthe CDO record IDA dictionary of the fieldName:value pairs you want to upload/updateA dictionary of the fieldName:fieldID pairs to map your fieldsNamesStep 2: bare bones initializationfrom python_eloqua_wrapper.cdo_record import CdoRecord
from python_eloqua_wrapper.eloqua_session import EloquaSession
from os import environ

session = EloquaSession(company=environ["ELOQUA_COMPANY"], 
                        username=environ["ELOQUA_USER"], 
                        password=environ["ELOQUA_PASSWORD"])

cdo_record = CdoRecord(session=session)That's it, you now have a local object!Step 3: Updating your recordThere is a method calledupdate_cdo_record, which can be used as follows:cdo_record.update_cdo_record(
    cdo_id=12345, 
    record_id=369789, 
    cdo_field_to_field_id_map={
        'zip_code': 11221,
        'job_title': 11232}, 
    record_fields_and_values_dict={
        'zip_code': '22667',
        'job_title': 'Alligator Wrangler'})Simply execute this and you will receive the response object if it was successful, else it will raise an exception.To be more explicit about update behavior:If a previous value for that field/column already existed: it gets overwritten.If you don't provide a field/column name, it won't alter that column.
Package: python-emacs
python-emacsThis package provides an interface between Python and GNU Emacs. It allows you to easily pass data
from Python to Emacs, execute Emacs Lisp code, and transfer the resulting data back to Python again.
It also provides utilities for building Emacs Lisp expressions in Python.InstallationInstall using pip:pip install python-emacsOr directly from the repository:git clone https://github.com/jlumpe/python-emacs
cd python-emacs
pip install .UsageCreate an interface to Emacs using eitherEmacsBatchorEmacsClient. The first runs a new Emacs
process in batch mode with every command, the second usesemacsclientto communicate with a
running server. Both follow the same API.>>> from emacs import EmacsBatch
>>> emacs = EmacsBatch(args=['-Q'])  # Don't load user config with each invocationExecute an Elisp expression and get the result:>>> emacs.eval('(+ 1 2)')
3

>>> emacs.eval('(format "One plus two is %d" (+ 1 2))')
'One plus two is 3'

>>> src = '''
... (progn
...   (require 'cl)
...   (cl-loop
...     for i in '(1 2 3 4 5)
...     collect (* i i)))
... '''

>>> emacs.eval(src)
[1, 4, 9, 16, 25]Evaluation errors are caught in Emacs and raised in Python:>>> emacs.eval('(+ 1 "foo")')
ElispException: Wrong type argument: number-or-marker-p, "foo"Write Elisp programs in Python>>> import emacs.elisp as el

>>> src = el.to_elisp((el.Symbol('format'), 'One plus two is %d', (el.Symbol('+'), 1, 2)))
>>> src
<el (format "One plus two is %d" (+ 1 2))>

>>> emacs.eval(src)
'One plus two is 3'Using a terrible DSL:>>> from emacs.elisp import E

>>> prog = E.with_output_to_string(
      E.dolist(
        (E.i, E.number_sequence(1, 20)),
        E.princ(E.i),
        E.when(E['='](E['%'](E.i, 3), 0), E.princ("fizz")),
        E.when(E['='](E['%'](E.i, 5), 0), E.princ("buzz")),
        E.princ('\n')))

>>> prog
<el (with-output-to-string (dolist (i (number-sequence 1 20)) (princ i) (when (= (% i 3) 0) (princ "fizz")) (when (= (% i 5) 0) (princ "buzz")) (princ "\n")))>

>>> print(emacs.eval(prog))
1
2
3fizz
4
5buzz
6fizz
7
8
9fizz
10buzz
11
12fizz
13
14
15fizzbuzz
16
17
18fizz
19
20buzz
Package: python-emailahoy
=Python EmailAhoy=A Python email utility that verifies existence of an email addressAuthor: `Val Neekman <val@neekware.com>`IntroductionUsage Example:--------------from emailahoy import VerifyEmail, verify_email_address# to verify and receive the response status use the class##############################################e = VerifyEmail()status = e.verify_email_smtp('test@example.com')if e.was_found(status):print >> sys.stderr, "Found:", statuselif e.not_found(status):print >> sys.stderr, "Not Found:", statuselse:print >> sys.stderr, "Unverifiable:", status# to just quickly check if an email exist or not use the shorthand function##############################################if verify_email_address('test@example.com'):print >> sys.stderr, "Found"else:print >> sys.stderr, "Not found"# Note:##############################################If email is valid, this returns within a secondIf email is not valid or unverifiable, it can take up to 5 seconds