Saravanan666/pypi-org huggingface dataset:
Package: epydz
PackageA python library containing useful functions.Installation:pip install epydzExample usagefrom epydz import *result = 5lokan(result == 5, lambda: werili(result))Functions:werili: #takes any number of arguments and concatenates them into a string separated by sep. The resulting string is then printed to the console followed by end.dekhel: #prompts the user for input and returns the user's response as a string.lokan:# takes a boolean condition and a function result_fn. If condition is True, the function result_fn is called and its result is returned. Otherwise, None is returned.ilokan: #similar to lokan, but returns a default value instead of None if the condition is false.tsema: #returns a default value for use in ilokan.akesam: #splits a string into a list of items based on a separator.akelab: #returns a reversed list of items.motawasit: #returns the average of a list of numbers.nisf: #returns the median of a list of numbersahseb: #returns the number of words in a string.dirr: #Loop for the specified maximum number (100) of iterations or until a non-None value is returned.
Package: epyestim
epyestimIntroductionepyestim estimates the effective reproduction number
from time series of reported case numbers of epidemics. It is a
Python reimplementation of the method outlined by
Huisman et al. [1], making use of the method by Cori et al. [2]
to estimate the reproduction number R from infection data,
available in the R package EpiEstim [3].The main steps for estimation of the effective reproduction number are:Bootstrapping the series of reported case numbersSmoothing using a LOWESS filterMLE of the infection incidence time series
using an adaptation of the Richardson-Lucy deconvolution algorithm.Bayesian estimation of the effective reproduction number using the
method of Cori et al. [2]Aggregate estimates for the reproduction number are obtained by bootstrap
aggregation (bagging).The user can choose to output either time-varying estimates or piecewise
constant estimates on fixed arbitrary time intervals.How to install epyestimpip install epyestimHow to use epyestimBasic usage of the epyestim package applied to COVID-19 data is explained
in theJupyter tutorial notebook.The core functions relevant for users are:epyestim.bagging_rfor the complete estimation process
outlined aboveepyestim.covid19.r_covidfor the same function with default
parameters for COVID-19epyestim.estimate_r.estimate_rfor the R estimation from
infection numbers, based on the EpiEstim packageAuthorsLorenz HilfikerJohannes JosiHow to contributeError reports and suggestions for improvements via GitHub issues
are very welcome.References[1] Jana S. Huisman, Jeremie Scire, Daniel Angst, Richard Neher,
Sebastian Bonhoeffer, Tanja Stadler: A method to monitor the effective
reproductive number of SARS-CoV-2https://ibz-shiny.ethz.ch/covid-19-re/methods.pdf[2] Anne Cori, Neil M. Ferguson, Christophe Fraser, Simon Cauchemez:
A New Framework and Software to Estimate Time-Varying Reproduction
Numbers During Epidemics, American Journal of Epidemiology, Volume 178,
Issue 9, 1 November 2013, Pages 1505–1512,https://doi.org/10.1093/aje/kwt133[3] EpiEstim CRAN package:https://cran.r-project.org/web/packages/EpiEstim/index.html
Package: epyfund
EPYFund - Test for quantitative trading.Only for testing now!
Only for testing now!
Only for testing now!The EPY project is an open-source quantitative trading framework
that is developed by traders, for traders.The project is mainly written in Python and uses C++ for low-layer
and performance sensitive infrastructure.Using the EPY project, institutional investors and professional
traders, such as hedge funds, prop trading firms and investment banks,
can easily develop complex trading strategies with the Event Engine
Strategy Module, and automatically route their orders to the most
desired destinations, including equity, commodity, forex and many
other financial markets.
Package: epyg
EpyG - Extended Phase Graphs in PythonAuthor: Daniel Brenner, (formerly) DZNE Bonn,
Started in: 2016, continued in 2022Extended Phase Graphs (EPG) are mathematical model of the signal evolution in magnetic resonance with particular applications
imaging (MRI).
This python implementation of the EPG formalism aim at being usable from a user perspective, being suited for educational
uses as well as providing adequate performance to allow 'real' applicaltions e.g. for more "heavy" simulations.
The overall implementation follows the Operator notation as e.g. shown by Weigel.The code is currently works in progress! Use with great care!InstallationEpyG is a pure python module built upon numpy.it usespoetryas build and distribution tool.Package structureThe EpyG package is structured in 3 modulesEpyG - the actual representation of an Extended Phase GrapOperators - implementation of Operators that manipulate EpyGApplications - combinations of operators and looping to simulate real life MRI problemsFirst stepsFor first steps it is advised to look at the example ipython/jupyter notebook(s) in the examples directoryTestingThe folder tests/ contains a set of unit/integration tests to prove basic functionality.
Further application examples can be found in the examples subfolder where Jupyter notebooks illustrating the major concepts are distributed
Package: epygma
![Epygma_logo_small.png](https://bitbucket.org/repo/AggpXXM/images/2338554317-Epygma_logo_small.png)--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------**CODE AUTHOR:** GALODE Alexandre**HISTORICAL RESEARCH:** GALODE Alexandre, FOURNIS Erwan**LICENCE:** GPL V3----------------------------------------------------------------------------------------Epygma project aims to reproduce ENIGMA with Python code.At the end of the project, user will have three way to use it:* As a package in command line or in a software* With the PyQt5 GUI* With an electronic card to reproduce a physical ENIGMA with a RPI-----------------------------------------------------------------------------------------**Tools used:*** IDE: Pycharm* Code quality: Pylint* Code complexity: McCabe
Package: epyk-flask
First Version out now!Web Server embedding theEpykPython Framework to allow you to leverage on the power of HTML and JS all from pythonInstallation:pipinstallepyk_flaskGet Started:epyk-flasknew-pserver_pathThis will create a new server structure at the path of your choiceepyk-flaskenv-pserver_path/epyk_flask/UI/scriptsThis will create a new environments where you want to store scripts that will use Epykepyk-flaskrun-pserver_pathThis will run your server and render your HTML pagesIf you want to know all the options and commands available in the epyk-flask CLI please run:epyk-flask-hConfiguration:The configuration for your server is located under:server_path/epyk_flask/configPlease be aware the epyk_flask is the name of your project by default but it can be different if you chose to create it with a different nameDocumentation:Please refer to the documentation from the package Epyk to get started with your first pages.
Package: epyk-materials
First Version out now!An easy way to use Epyk with the Material Components extension.PresentationThis package will make a simple interface between most of the components of Materials components
and Epyk. This addon will allow you to benefit from the two world and to keep write Interactive and modern web pages from Python.https://material-ui.com/Compatibilityepyk is compatible with the most common Web Python Frameworks (Flask and Django).
By default, the server package embeds a Flask app as it is easier to install and ready to use.The Extension (with Epyk-UI) can be included within a Jupyter or JupyterLab project. But this will lead to some limitations - for example Ajax and Socket will not be available.The Material extension will add extra components with a more advanced design. Those components are integrated within
the framework and all the underlying event, interactivities and styling features can be reused.Also it is possible to mix the components and to use Epyk-UI ecosystem with Material UI.
Package: epylog
EPYLOGLogs are the first.This is a simple wrapper to standardlogginglibrary for Python.Epylog provides to send log data to different sources e.g. file, rsyslog, graylog, http, etc.Use different loggers for different needs and manage it from one place.InstallationpipinstallepylogUsageMove to project root directory and createlogging.cfgfile:cd/project/root
touchlogging.cfgFill configuration file with you logging settings. Push totargetsarray everything you want to send to. And fillrulesarray with logger names (use*wildcard if you want) and set which targets loggers can use:{"targets":[{"name":"fl","type":"file","filename":"/var/log/my_log.log"},{"name":"gl","type":"graylog","host":"localhost","port":12202,"facility":"test"},{"name":"rsl","type":"syslog","address":"localhost","facility":"test"}],"rules":[{"name":"my_test_*","min-level":"info","write-to":"fl, gl","format":"%(asctime)s - %(name)s - %(levelname)s - %(message)s"},{"name":"*","min-level":"warning","write-to":"rsl","format":"%(asctime)s - %(name)s - %(levelname)s - %(message)s"}]}Finally callgetLoggerfunction to initialize your logger:fromepylogimportLogger# put some code herelogger=Logger.getLogger('my_test_logger')logger.info('Hello from%s',logger.name)Enjoy sending your logs everywhereConfiguration referencelogging.cfgis a simple JSON object that descxribes all sources that you planning to use and associates loggers with this sources.TargetsTagretsare sources where can you send your logs....{"name":"fl","type":"file",...}...FieldDescriptionnameUnique name of targettypeTarget type. Now availiblefile,watch-file,syslog,httpandgraylogtarget typesother fieldsOther fields associated with specific target e.g.filename,host,facility, etc.RulesRulesare patterns for associating user loggers with specific configuration....{"name":"my_test_*","min-level":"info","write-to":"fl, gl","format":"%(asctime)s - %(name)s - %(levelname)s - %(message)s"}...FieldDescriptionnameUnique name(s) of logger given bygetLoggermethod. Use*wildcard for applying same settings for group of loggersmin-levelMinimum logging levelwrite-toTarget names splitted by comma without whitespases that will be asociated with this logger(s)formatLog lineformatLicense
Package: epyper
epyper======![demo](https://raw.github.com/mnowotka/epyper/master/doc/demo.jpg)Python driver for Embedded Artists 2.7 inch E-paper Display Module:http://www.embeddedartists.com/products/displays/lcd_27_epaper.php.It's based on original C code available here:http://www.embeddedartists.com/sites/default/files/support/displays/epaper/epaper_pi_130307.tar.gz[![Downloads](https://pypip.in/v/epyper/badge.png)](https://pypi.python.org/pypi/epyper)Rationale--------So you got your new shiny E-paper display from Embeded Artists. You plug it to your rPi to display some images. But how? Example C code is not very easy to adapt. All images included in C demo are written as byte tables in C header files. Function for displaying an image takes pointers to `int8_t`... In order to display new image you need to remember and old one. WTF!?!? You just wanted to display a png or jpg from your disk or web. And preferably do so in python. If that's your story then `epyper` is just for you.`Epyper` provides high level python interface for displaying images on e-paper. The most important class is `DisplayController`, which provides `displayImg` method accepting PIL `Image` to be displayed. The image needs to have proper size. It doesn't necessary needs to be black and white only - color images will be converted but the effect may be dissapointing so it's better to provide b&w or convert it before handing it to the `DisplayController`.Installation--------The best way to install epyper is to use `PIP`:pip install epyperThis command will install latest stable version with all dependencies.You can of course clone development version from github but it's not guaranteed to be working.How to use it?--------#necessary imports firstfrom PIL import Imagefrom epyper.displayCOGProcess import Displayfrom epyper.displayController import DisplayController#create DisplayController instance specifying display type as an argumentdisplay = DisplayController(Display.EPD_TYPE_270)#open some imageim = Image.open("some_image.png")#display it!display.displayImg(im)Dependencies--------* [WiringPi2-Python] (https://github.com/WiringPi/WiringPi2-Python)* [Pillow] (https://github.com/python-imaging/Pillow)
Package: epypes
EPypesEPypes (forevent-driven piplines) is a Python library for developing data processing algorithms in a form of computational graphs and their integration with distributed systems based on publish-subscribe communication. The initial use case of EPypes is computer vision alogorithms development, although it is suitable for any algorithm that can be expressed as a directed acyclic graph.EPypes facilitates flexibility of algorithm prototyping, as well as provides a structured approach to managing algorithm logic and exposing the developed pipelines as a part of on-line publish-subscribe systems. Currently, ZeroMQ middleware is supported, with data serialization based on Protocol Buffers.ModulesThe most important modules include:compgraph,graph-- primitives for construction and execution of computational graphspipeline,node-- primitives for extendind computational graphs with additional functionality, specifically the reactive behaviorzeromq-- adapters to ZeroMQ middlewarereactivevision-- functionality for creation of reactive computer vision componentsInstallation and requirementsThe core dependencies for the EPypes codebase includepyzmq,protobuf, andnetworkx>=2.0. They are listed in therequirements.txtfile, and can be installed in one of the following ways:# using pip$pipinstall-rrequirements.txt# using conda$whilereadrequirement;docondainstall--yes$requirement-cconda-forge;done<requirements.txtUsage examplesThe example below demostrates construction and execution of a computational graph. The demonstrated algorithm accepts a BGR image, converts it to grayscale, blurs the grayscale, and feeds the blurred image to the Canny edge detector.importcv2fromepypes.compgraphimportCompGraphfromepypes.compgraphimportCompGraphRunnerdefgrayscale(im):returncv2.cvtColor(im,cv2.COLOR_BGR2GRAY)defgaussian_blur(im,kernel_size):returncv2.GaussianBlur(im,(kernel_size,kernel_size),0)if__name__=='__main__':func_dict={'grayscale':grayscale,'canny':cv2.Canny,'blur':gaussian_blur}func_io={'grayscale':('image','image_gray'),'blur':(('image_gray','blur_kernel'),'image_blurred'),'canny':(('image_blurred','canny_lo','canny_hi'),'edges'),}hparams={'blur_kernel':11,'canny_lo':70,'canny_hi':200}cg=CompGraph(func_dict,func_io)runner=CompGraphRunner(cg,hparams)im=cv2.imread('my_image.jpg',cv2.IMREAD_COLOR)runner.run(image=im)For more complex computational graphs examples, refer to the following Jupyter notebooks:Simple lane lines detection (Udacity CarND project)More advanced lane lines detection (Udacity CarND project)
Package: epys
ePYs is a python library for the manipulation, processing and plotting of
the input and output files of ESA Experiment Planning Software (EPS).Free software: BSD licenseDocumentation:http://epys.rtfd.org.Modulesdrawmakes pretty orbit graphicseventsprovides a series of time/date utilitiesmapsdoes things with maps and imagesorbitprocesses mission analysis orbit filesreadreads EPS/MAPPS output into useable dataframes and/or arraysutilsmore utilities …
Package: epyseg
EPySegEPySeg is a package for segmenting 2D epithelial tissues.EPySeg also ships with a graphical user interface that allows for building, training and running deep learning models. Training can be done with or without data augmentation (2D-xy and 3D-xyz data augmentation are supported). EPySeg relies on thesegmentation_modelslibrary. EPySeg source code is availablehere. Cloud version availablehere.InstallInstallpython 3.7orAnaconda 3.7(if not already present on your system)In a command prompt type:pip install --user --upgrade epysegorpip3 install --user --upgrade epysegNB:To open acommand promptonWindowspress'Windows'+Rthen type'cmd'To open acommand promptonMacOSpress'Command'+Spacethen type in'Terminal'To open the graphical user interface, type the following in a command:python -m epysegorpython3 -m epysegThird party librariesBelow is a list of the 3rdparty libraries used by EPySeg and/or pyTA.IMPORTANTLY: if you disagree with any license below, please uninstall EPySeg.Library nameUseLinkLicensetensorflowDeep learning libraryhttps://pypi.org/project/tensorflow/Apache 2.0segmentation-modelsModelshttps://pypi.org/project/segmentation-models/MITczifileReads Zeiss .czi fileshttps://pypi.org/project/czifile/BSD (BSD-3-Clause)MarkdownPython implementation of Markdownhttps://pypi.org/project/Markdown/BSDmatplotlibPlots images and graphshttps://pypi.org/project/matplotlib/PSFnumpyArray/Image computinghttps://pypi.org/project/numpy/BSDPillowReads 'basic' images (.bmp, .png, .pnm, ...)https://pypi.org/project/Pillow/HPNDPyQt5Graphical user interface (GUI)https://pypi.org/project/PyQt5/GPL v3read-lifReads Leica .lif fileshttps://pypi.org/project/read-lif/GPL v3scikit-imageImage processinghttps://pypi.org/project/scikit-image/BSD (Modified BSD)scipyGreat library to work with numpy arrayshttps://pypi.org/project/scipy/BSDtifffileReads .tiff files (also reads Zeiss .lsm files)https://pypi.org/project/tifffile/BSDtqdmCommand line progresshttps://pypi.org/project/tqdm/MIT, MPL 2.0natsort'Human' like sorting of stringshttps://pypi.org/project/natsort/MITnumexprSpeeds up image mathhttps://pypi.org/project/numexpr/MITurllib3Model architecture and trained models downloadhttps://pypi.org/project/urllib3/MITqtawesomeElegant icons in pyTAhttps://pypi.org/project/QtAwesome/MITpandasData analysis toolkithttps://pypi.org/project/pandas/BSD (BSD-3-Clause)numbaGPU acceleration of numpy opshttps://pypi.org/project/numba/BSDelasticdeformImage deformation (data augmentation)https://pypi.org/project/elasticdeform/BSDCARE/csbdeeppyTA uses custom trained derivatives of the CARE surface projection model to generate (denoised) surface projectionshttps://pypi.org/project/csbdeep/BSD (BSD-3-Clause)
Package: epytech
DocumentationDocumentationAutologinInstall:pip install --upgrade epytechImportfromepytechimportsession,user,login,notifExample:fromepytechimportuser,session,login,notifclasscontent:# Initialisation of the classesuser=user.init()login=login.init()notif=notif.init()key=session.create("https://intra.epitech.eu/******************")defloader():# Load the content into the classescontent.user.load(content.key)content.login.load(content.key)content.notif.load(content.key)deftest():i=0loader()ifcontent.login.search('message')=="Success":print("Login Success")print("Welcome%s"%content.user.search('login'))ifcontent.notif.data:ifcontent.notif.len()>1:print("Your Notifications:\n")whilei<content.notif.len():print(content.notif.search(i))i+=1else:print("Your notification:%s"%content.notif.search(0))else:print("Login Failed")test()Result:Login Success
Welcome *********@epitech.eu
You have a notification: Your login time is insufficient (0).
Package: epytext2rst
eyptext2rst is a command line tool to convert epytext markup language in RestructuredText.General usageepytext2rst.py [-h] [-v] [-o OUTPUT] input

positional arguments:
    input input file or directory to convert

optional arguments:
    -h, --help show this help message and exit
    -v, --verbose show changes
    -o OUTPUT, --output-dir OUTPUT directory for output of parsed filesTo convert all python files (.py, .pyw) in a directory just type this:python epytext2rst.py mydirectory -o newdirectoryIf you just want to know what gets substituted do this:python epytext2rst.py mydirectory -vConventionepytext2rsthandles the conversion of the following Epytext
components:Keywords@(param|type|rtype|return|ivar) --> :(param|type|rtype|return|ivar)ItalicsI\{(.*?)\}    --> *..*BoldB\{(.*?)\}    --> **..**CodeC\{(.*?)\}    --> ``...``
Package: epythet
epythetDocumentation and packaging tools.
Less humdrum, more automation, earlier at the pub.Full documentation heregenerated by Epythet.Getting StartedFollow theSphinx Installation Guidepip install epythetFollow the shortQuickstart GuideAboutTired of learning new frameworks and just need something to quickly display your docstrings in your python files? You've come to the right place. Epythet is built onSphinx Python Documentation Generatorbut automatically generates pages for each module .py files and a table of contents.Publishing to GitHub Page with GitHub ActionsAdd workflow.github/workflows/publish-docs.ymlto your repo and modify the trigger conditions to suit your needs.  Example below will run automatically when the other "Continuous Integration" workflow is completed.name: GitHub Pages

on:
  workflow_run:
    workflows: ["Continuous Integration"]
    types:
      - completed

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: i2mint/epythet/actions/publish-github-pages@master
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          docs-branch: "gh-pages"
          docs-dir: "./docsrc/_build/html/"
          python-version: "3.10"Setup the GitHub Pages for your repo after the target docs-branch is created.  Set the target branch (default: "gh-pages") and folder as/(root)