Saravanan666/pypi-org huggingface dataset:
Package: e
For example:$ python -me 1 + 1
2Like python -c but no need for a print. But wait, there’s more.As a bonus, if the first argument is a module name then it will output the
location of the module source code:$ python -me os
/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/os.pyIf you follow the name of the module with a command then the module will be
opened with that command. For example, the following will open the os module
source in vim:$ python -me os vimThe “e” module recognises the special command names “edit” and “view” which
will result in it looking up your editor and viewer commands in the
environment variables $EDITOR and $PAGER respectively. The latter defaults to
“less”. This is slightly easier than writing, for example:$ vim `python -me os`… especially if you’re going back to edit a previous “python -me” command
using line editing.Also, “python -me help” is a shortcut to Python’s interactive help mechanism.Idea from Georg Brandl. Foolishly implemented by Michael Foord and Richard
Jones.
Package: e1
e1.pyPython support for the e1 seismic compression format."e1" is a variable-length compression algorithm for int32 data.Installationpipinstalle1UsageDecompress data from a fileimporte1file_name='some_file.w'byte_offset=0nsamples=1000withopen(file_name,'rb')asf:f.seek(byte_offset)data=e1.decompress_file(f,nsamples)Decompress raw byteswithopen(file_name,'rb')asf:# Read 5 times as many bytes as you expecte from nsamples x 4-byte values,# just to make sure all your nsamples are in it.  Though it may be more data# than you need, this gaurds against poorly-compressed data.# In e1, you don't know a priori how many bytes it took to compress your data.nbytes=5*nsamples*4byts=f.read(nbytes)data=decompress(byts,nsamples)
Package: e13tools
DescriptionThis package contains a collection of utility functions that were created by@1313e.
Most functions were created for personal use, but have been changed and optimized to work for others as well.How to installe13Tools can be found in the PyPI system, sopip install e13toolsshould suffice.Dependenciese13Tools requires:python >= 3.6,matplotlib >= 2.2.4,numpy >= 1.8.The following packages are used by a few functions and therefore optional:astropy >= 1.3.
Package: e220-900t22s
RPi_E220-900T22S_LoRa_libraryE220-900T22S Python Library for Raspberry PiInstallationpip install e220-900t22sExample# uart setupsudousermod-aGdialout<username>
sudousermod-aGgpio<username>
sudoraspi-config->InterfaceOptions->SerialPort->PCserial:no->Hardwareserial:yes->ok# rebootSample Code
Package: e24PaymentPipe
This package provides a Python implementation for ACI’s e24PaymentPipe Merchant GatewayNoteFor legacy reasons, the name of the module is kept the same as the one from ACI’s toolkit. This does not
conform to PEP-8 guidelines.Free software: BSD licenseDocumentation:http://e24PaymentPipe.rtfd.org.FeaturesWritten in Python from scratch (not an existing port)Supports both newer and legacy terminal resource (.cgn) file formatsReasonably well documentedProven code - running in production since 2011No external dependenciesCompatible with Python 3.4, Python 2.7TodoAdd support for credit card payments, including refunds.Create comprehensive test suiteHistory1.2.0 (2015-12-29)Now compatible with Python 3.4!Added requests as a dependency1.1.2 (2014-11-03)Fixed issue iterating over UDF dictionary keysFixed issue where unicode was being passed to sanitize
unicode strings are not allowed in UDF fields1.1 (2014-08-12)Refactored class methods toutils.pyPEP-8 cleanupVersion bump0.1.0 (2011-02-12)First release on Github.0.1.1 (2011-02-14)Added custom exceptions0.1.2 (2011-12-16)Optimized error checkingAdded character filters for UDF as per latest payment provider update0.2.0 (2011-12-28)Version branch created with major changes in the codebaseCleaned up the API and interface
Package: e2b
Sandbox for AI Apps & AgentsSecure sandboxed cloud environments made for AI agents and AI appsDocs|Website|Discord|TwitterWhat is E2B?E2B Sandbox is a secure sandboxed cloud environment made for AI agents and AI
apps. Sandboxes allow AI agents and apps to have long running cloud secure
environments. In these environments, large language models can use the same
tools as humans do. For example:Cloud browsersGitHub repositories and CLIsCoding tools like linters, autocomplete, "go-to defintion"Running LLM generated codeAudio & video editingThe E2B sandbox can be connected to any LLM and any AI agent or app.Getting Started & DocumentationPlease visitdocumentationto get started.To create and control a sandbox, you use our SDK:Install SDKpipinstalle2bStart sandboxfrome2bimportSandbox# Create sandboxsandbox=Sandbox()# Let an LLM use the sandbox here# Visit https://e2b.dev/docs/sandbox/overview to learn more about sandboxes.# Close sandbox once donesandbox.close()
Package: e2c
DocumentationMasterDevelopTestsE2C.py - Elastic Event Components for PythonElastic Event Componentsis an open source software library to build flexible architectures using
dataflow graphs. A graph node represents any operation, while the graph edges represent the data
of the operation. Each parameter can be bound to any number of operations and thus brought
into a flow. Elastic Event Components also includes flow visualization.Through E2C, processes and software architectures can be visualized by dataflow graphs,
which can be converted into executable applications.Functional dependencies can be defusedby E2C and thus significantly increase the changeability and quality of
components and software projects.InstallationSeeInstalling E2Cfor instructions
on how to build from source.Try your first E2C program$python>>>importe2c>>>config=(...'.run -- action',...'action.render -- render',...'   render.out -- .out',...'action.log -- log',...'   log.store -- .out')>>>defaction(data:str,render,log):...render(data)...log('Render done!')>>>graph=e2c.Graph[str,str](config)>>>graph.actor('action',action)>>>graph.actor('render',lambdadat,out:out(dat))>>>graph.actor('log',lambdadat,store:store(dat))>>>graph.visualize()>>>graph.run_continues('Hello, E2C',print)Hello,E2CRenderdone!For more informationRead thelecturesto learn more about E2c or visit theE2C websiteLicenseApache 2.0 License
Package: e2eAIOK-recdp
RecDP - one stop toolkit for AI data processWe provide intel optimized solution forAuto Feature Engineering-  Provides an automatical way to generate new features for any tabular dataset which containing numericals, categoricals and text features. It only takes 3 lines of codes to automatically enrich features based on data analysis, statistics, clustering and multi-feature interacting.LLM Data Preparation- Provides a parallelled easy-to-use data pipeline for LLM data processing. It supports multiple data source such as jsonlines, pdfs, images, audio/vides. Users will be able to perform data extraction, deduplication(near dedup, rouge, exact), splitting, special_character fixing, types of filtering(length, perplexity, profanity, etc), quality analysis(diversity, GPT3 quality, toxicity, perplexity, etc). This tool also support to save output as jsonlines, parquets, or insertion into VectorStores(FaissStore, ChromaStore, ElasticSearchStore).How it worksInstall this tool through pip.DEBIAN_FRONTEND=noninteractive apt-get install -y openjdk-8-jre graphviz
pip install pyrecdp[all] --preRecDP - Tabularlearn moreAuto Feature Engineering PipelineOnly3lines of codes to generate new features for your tabular data. Usually 5x new features can be found with up to 1.2x accuracy boostfrom pyrecdp.autofe import AutoFE

pipeline = AutoFE(dataset=train_data, label=target_label, time_series = 'Day')
transformed_train_df = pipeline.fit_transform()High Performance on Terabyte Tabular data processingRecDP - LLMlearn moreLow-code Fault-tolerant Auto-scaling Parallel Pipelinefrom pyrecdp.primitives.operations import *
from pyrecdp.LLM import ResumableTextPipeline

pipeline = ResumableTextPipeline()
ops = [
    UrlLoader(urls, max_depth=2),
    DocumentSplit(),
    ProfanityFilter(),
    PIIRemoval(),
    ...
    PerfileParquetWriter("ResumableTextPipeline_output")
]
pipeline.add_operations(ops)
pipeline.execute()LICENSEApache 2.0DependencySpark 3.4.*python 3.*Ray 2.7.*
Package: e2e-cli
E2E CLIStable Release : version - 0.9.20The  E2E  Command  Line  Interface is a unified tool to manage all your E2E services
A command line tool developed by E2E Networks LtdGetting startedJust Login to yourE2E myAccountand get your access tokens.
For more on access token referE2E TokensAdd this to your system and you are all set to go.RequirementsThe e2e-cli package works on Python versions:3.x and greater
setuptools 45.2.0 or greater
requests 2.22.0 or greaterNoticesAttention!
We recommend that all customers regularly monitor theE2E docswebsite for any important update bulletins related to e2e-cli.InstallationInstallation of the E2E CLI and its dependencies use a range of packaging features provided by pip and setuptools. To ensure smooth installation, it’s recommended to use:pip: 21.0 or greater
requests: 2.22.0 or greater
setuptools: 45.2.0 or greaterThe safest way to install the E2E CLI is to use pip in a virtualenv:
pip install e2e-cliConfigurationBefore using the E2E CLI, you need to configure your E2E credentials/Tokens
This can be done by running the following commands to add token,more:e2e_cli alias add      ->   To add api key and auth token
e2e_cli alias add_file ->   To add api key and auth token via fileFurther set default token by using :e2e_cli alias set      ->   To set default alias for systemBasic CommandsAn E2E CLI command has the following structure:e2e_cli <command> <subcommand> [options and parameters]For example, to list buckets, the command would be:e2e_cli bucket listTo view help/man documentation, use one of the following:e2e_cli helpTo get the version of the E2E CLI:e2e_cli --version/-vTo get the package info of the E2E CLI:e2e_cli --infoTo turn on debugging :e2e_cli <command> <subcommand> --debugTo get API arguments info :e2e_cli <command> <subcommand> --infoSupportFor support/help referE2E CLI docsor visitE2E NetworksAuthors and acknowledgmentAman and Sajal, E2E Networks Ltd.Project statusCurrently undergoing feature upgrades
Package: e2e.common
e2e.commonCommon code for the Python E2E package ecosystem.This package complies with PEP-484, PEP-526, and PEP-561 for distribution of
type information.Core Modulese2e.common.modelling: Object-based Modelling FrameworkA modelling framework is provided bymodelling.NamedParentable, using
metaclass construction to stitch instance parents together in a class-based
modelling approach.For examples on how this is used, please seee2e.pomore2e.api, as both packages use this
modelling approach as of their 1.x releases.For the 1.0 release, onlyNamedParentableis provided and requires users to
explicitly name instances of models for best-possible human-friendly logging.For the 2.0 release, options will exist for auto-naming and omission of the
naming requirement. Stay tuned.e2e.common.utils: General Utility FunctionsGeneralised utility functions reside in here. To reside here, they must be used
by more than one e2e.* package.CompatibilityPython 3.6+ is requireddue to various metaclass and type-hinting
functinality used. Backporting to 3.5 is possible with more significant effort
and potential loss of certain features and type-hinting; please file an issue
if you require this, explaining the motivation if possible.Other than that, this is a pure Python package and should be compatible with
any OS and platform which Python runs on.Contributing & DevelopmentI haven’t put much thought into others contributing here. Please reach out if
there are changes you’d like to make!TheMakefile(which has only been tested on Linux distros) holds my
development process:make format: to runblackandisortformattersmake lint: to runmypy(type check),pylint, andflake8make test: to run unit testsmake tox: to run unit tests on multiple Python versionsmake wheelandmake sdist: to build such package archivesOtherwise, this is a fairly standard package repo using virtual environments
andsetup.py.Note that the build environment (no unnecessary packages) is different from the
development environment (contains all packages for development).Changelog0.1.4 (2022-09-12)[Issue 1] Respect parent overrides in functions0.1.3 (2020-10-16)Fixed an issue where importing the library would result in
no child modules being available.0.1.2 (2020-07-22)Better PyPI rendering0.1.1 (2020-07-22)Initial release, including class-based modelling framework.Copyright 2017-2020 Nicholas KroekerLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: e2e.env
e2e.envClass-based modeling of environment variables and their type conversions.Especially suited to test automation where environment variables are used in
abundance, or even in applications that could benefit from these mappings.RequirementsFor ease of implementation, Python 3.6 is required in order to usePEP-526variable
annotations.OverviewEnvironment variable access is common, and usually done via a module-based
approach.SERVICE_HOST=os.getenv('COMPANY_APP_HOST')SERVICE_PORT=int(os.getenv('COMPANY_APP_PORT'))This works just fine, but sometimes they need to be refreshed...# Whoops, forgot the int conversion!SERVICE_PORT=os.getenv('COMPANY_APP_PORT')... which isn't veryDRY.Additionally, you may sometimes need to keep track of the nameandthe value from the environment,# This is getting verbose quicklyENVNAME_SERVICE_HOST='COMPANY_APP_HOST'SERVICE_HOST=os.getenv(ENVNAME_SERVICE_HOST)ENVNAME_SERVICE_PORT='COMPANY_APP_PORT'SERVICE_PORT=int(os.getenv(ENVNAME_SERVICE_PORT))In one swoop, we can map the environment variables as well as their
conversions to native types, and fetch either the value or the name:classServiceVars(e2e.env.EnvMapper):host:str='COMPANY_APP_HOST'port:int='COMPANY_APP_PORT'# Get the port via instanceprint(ServiceVars().port)# 8080type(ServiceVars().port)# <class 'int'># Get the name of the port environment variable via classprint(ServiceVars.port)# COMPANY_APP_PORTtype(ServiceVars.port)# <class 'str'>Using your own "converters"AllEnvMapperdoes is read the type annotation and constructs the returned
value by passing the environment value to it.That is, when modeling,mapped_name:annotated_type='ENV_VAR_NAME'... on access via theEnvMapperinstance, becomes ...annotated_type(os.getenv('ENV_VAR_NAME'))In the above examples for example, we hadport: int = 'COMPANY_APP_PORT'.
This essentially gets shuffled intoint(os.getenv('COMPANY_APP_PORT')). So
any callable that can take a singlestrin its constructor and return the
appropriate type will work.Production useThe code is incredibly simple, and will adhere to these contracts:Variables that do not exist will cause ae2e.env.exceptions.NoSuchVariableErrorto be raised.*Access of an unmapped environment variable will raise anAttributeError, as
would be reasonably expected.Access of a mapping without an annotation will raise aTypeErrorwith the
mapping name and model class.* Open for discussion. ReturningNonecould work. PassingNoneto the type
converter usually won't produce consistent behaviour across types, and so can't
be determined as a special case (e.g.str(None)gives"None",int(None)raises aTypeError). SeeIssue #1for more info.Future workSupportraise_on_dneor something similar to change what happens when an
environment variable is not found. Please add a thumbs-up forIssue #1if you'd like to
see this feature.classServiceVars(e2e.env.EnvMapper,raise_on_dne=False):...classServiceVars(e2e.env.EnvMapper,dne=lambda:None):...Support for combining mappings into one larger mapping, for organizational
purposes. Please add a thumbs-up forIssue #2if you'd like to
see this feature.
Package: e2efs
E2E-FSE2E-FS: An End-to-End Feature Selection Method for Neural NetworksCONTACTThis project is hosted athttps://github.com/braisCB/E2E-FS.REFERENCEIf you plan to use this code, please cite the following paper:Cancela, B., Bolón-Canedo, V., & Alonso-Betanzos, A. (2020).
E2E-FS: An End-to-End Feature Selection Method for Neural Networks.
IEEE Transactions on Pattern Analysis and Machine Intelligence.(Pending on publication)EXAMPLE OF USE# REQUIRED IMPORTS TO CREATE THE MODEL
from keras.datasets import mnist
from keras.callbacks import LearningRateScheduler
from keras.utils import to_categorical
from keras import optimizers, models, layers
# E2EFS IMPORT
from e2efs import models


# DEFINE YOUR CLASSIFIER
def three_layer_nn(input_shape, nclasses):
    return models.Sequential([
        layers.Flatten(input_shape=input_shape),
        layers.Dense(50),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.Dense(25),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.Dense(10, activation='softmax')
    ])


if __name__ == '__main__':

    ## LOAD DATA
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    x_train = np.expand_dims(x_train, axis=-1)
    x_test = np.expand_dims(x_test, axis=-1)
    y_train = to_categorical(y_train)
    y_test = to_categorical(y_test)

    ## LOAD MODEL AND COMPILE IT (NEVER FORGET TO COMPILE!)
    model = three_layer_nn(input_shape=x_train.shape[1:], nclasses=10)
    model.compile(optimizer=optimizers.SGD(), metrics=['acc'], loss='categorical_crossentropy')

    ## LOAD E2EFS AND RUN IT
    fs_class = models.E2EFSSoft(n_features_to_select=39).attach(model).fit(
        x_train, y_train, batch_size=128, validation_data=(x_test, y_test), verbose=2
    )

    ## FINE TUNING
    def scheduler(epoch):
        if epoch < 20:
            return .1
        elif epoch < 40:
            return .02
        elif epoch < 50:
            return .004
        else:
            return .0008

    fs_class.fine_tuning(x_train, y_train, epochs=60, batch_size=128, 
                         validation_data=(x_test, y_test),
                         callbacks=[LearningRateScheduler(scheduler)], verbose=2)
    print('FEATURE_RANKING :', fs_class.get_ranking())
    print('ACCURACY : ', fs_class.get_model().evaluate(x_test, y_test, batch_size=128)[-1])
    print('FEATURE_MASK NNZ :', np.count_nonzero(fs_class.get_mask()))
Package: e2e-mobile
e2e-mobileis a Python package providing convenient setup for end-to-end testing in mobile apps. This package is the combined magic of Appium and Pytest. It helps us:Write tests once, for both platforms (iOS & Android).Write reusable & readable tests that can scale to support complex use cases.What does a test with this framework look like?frome2eimportTesterdeftest_tutorial(tester:Tester):tester.ui.home.skip_tutorial()tester.relaunch_app()tester.ui.home.must_not_see_tutorial()deftest_settings(tester:Tester):tester.ui.home.skip_tutorial()tester.ui.home.go_to_settings()tester.ui.settings.swipe('up')tester.ui.settings.element('About the app').must_exist()tester.ui.settings.swipe('down')tester.ui.settings.close()Get started with e2e-mobile now!Installatione2e-mobileisavailable on PyPI (Python Package Index). You can install with withpip:$pipinstall--upgradee2e-mobileFirst time hearingpip? Check thisFAQ.UsageKindly check out the related docs onreadthedocs:Getting StartedDocumentationKindly check out the related docs onreadthedocs:API ReferenceContributingRefer to thecontributing guidelinesfor how to contribute to this project.
Package: e2fyi-pyspark
e2fyi-pysparke2fyi-pysparkis ane2fyinamespaced python package withpysparksubpackage
(i.e.e2fyi.pyspark) which holds a collections of useful functions for common
but painful pyspark tasks.API documentation can be found athttps://e2fyi-pyspark.readthedocs.io/en/latest/.Change logs are available inCHANGELOG.md.Python 3.6 and aboveLicensed underApache-2.0.Quickstartpipinstalle2fyi-pysparkInfer schema for unknown json strings inside a pyspark dataframee2fyi.pyspark.schema.infer_schema_from_rowsis a util function to infer the
schema of unknown json strings inside a pyspark dataframe - i.e. so that the
schema can be subsequently used to parse the json string into a typed data
structure in the dataframe
(seepyspark.sql.functions.from_json).importpysparkfrome2fyi.pyspark.schemaimportinfer_schema_from_rows# get spark sessionspark=pyspark.sql.SparkSession.builder.getOrCreate()# load a parquet (assume the parquet has a column "json_str", which# contains a json str with unknown schema)df=spark.read.parquet("s3://some-bucket/some-file.parquet")# get 10% of the rows as sample (w/o replacement)sample_rows=df.select("json_str").sample(False,0.01).collect()# infer the schema for json str in col "json_str" based on the sample rows# NOTE: this is run locally (not in spark)schema=infer_schema_from_rows(sample_rows,col="json_str")# add a new column "data" which is the parsed json string with a inferred schemadf=df.withColumn("data",pyspark.sql.functions.from_json("json_str",schema))# should have a column "data" with a proper schemadf.printSchema()
Package: e2m
Email to maildir syncSync your emails to maildir (currently only imap supported)Installpip install e2mGetting startedConfig file required in the homedir.e2mrcwith next format.$ cat ~/.e2mrc
[job]
email = [name]@[domain]
pswd = [password]
imap_host = imap.gmail.com
imap_port = 993
keep = 256You can specify multiple sections with different accoutns.Then add it to your crontab*/2 * * * * /usr/local/bin/e2m 2>&1 >/dev/null
Package: e2s
eijiro-to-sqlite英辞郎-> sqlite3Sample data: 0 JPY英辞郎 Ver.144.8: 495 JPYScreenshotInstallpipinstalle2sRunwget'https://www.eijiro.jp/eijiro-sample-1448.zip'# sample dataunzipeijiro-sample-1448.zip
e2s-iEIJIRO-SAMPLE-1448.TXT# `eijiro.db` will be createdHelp$ e2s -h
usage: e2s [-h] [-i TXT] [-o DB] [-j JOINER] [-O] [-V]

Convert eijiro(英辞郎) text data into sqlite3

optional arguments:
  -h, --help                  show this help message and exit
  -i TXT, --input TXT         Source file (default: EIJIRO-1448.TXT)
  -o DB, --out DB             Output DB file (default: eijiro.db)
  -j JOINER, --joiner JOINER  Joiner for descriptions (default: ^^^)
  -O, --overwrite             Overwrite db (default: False)
  -V, --version               show program's version number and exitSchemaCREATETABLEword(idintegerprimarykey,wordtext,meaningtext,descriptionstext)
Package: e2xauthoring
e2xauthoringe2xauthoring is an add-on for e2xgrader that adds functionality for authoring assignments.
e2xauthoring streamlines assignment creation for nbgrader by utilizing reusable components known astasksandtemplates.
Please refer to thedocumenationfor further information.ScreenshotsCreate a task from question presets:Creating a worksheet from tasks and a template:Requirementse2xcoreInstallThe add-on is automatically installed alongside e2xgrader.
To install it yourself, execute:pipinstalle2xauthoringUninstallTo uninstall, execute:pipuninstalle2xauthoring
Package: e2xgrader
e2xgradere2xgrader is an add-on for nbgrader that adds functionality for teachers and students.
e2xgrader introduces new cell types and tools for graders (per question grading view, authoring component, pen-based grading) and students (assignment toolbar, exam toolbar, restricted notebook extension).
Please refer to thedocumentationfor further information.Currently e2xgrader works with notebook<7 or nbclassic. We are working on porting the notebook extension to lab extensionsScreenshotsA multiple choice cell:An annotated student answer:A per question grading view for teachers:A help extension to make docs and other files available to students:An assignment toolbar for students:An exam toolbar for students:JupyterCon 2023 TalkInstallTo install e2xgrader, execute:pipinstalle2xgraderChange Modee2xgrader comes in three different modes,teacher,studentandstudent_exam.
You can switch between them:e2xgraderactivateteacher--sys-prefix
e2xgraderactivatestudent--sys-prefix
e2xgraderactivatestudent_exam--sys-prefixUninstallTo uninstall, execute:e2xgraderdeactivate--sys-prefix
pipuninstalle2xgrader