Saravanan666/pypi-org huggingface dataset:
Package: yabin
YABin CLI ClientInstallationpipinstallyabinUsageYou can specify theBASE_URLenvironment variable to change the default API URL, or use the-b/--base-urloption.Create a pasteusage: yabin create [-h] [--encrypted] [--password PASSWORD] [--language LANGUAGE] [--expires-after SECONDS] [--burn-after-read] FILE|stdin

positional arguments:
  FILE|stdin            Content of the paste. If it is stdin, it will be read from stdin

options:
  -h, --help            show this help message and exit
  --encrypted, -e       Encrypt the paste on client-side. Default: False
  --password PASSWORD, -p PASSWORD
                        Password to encrypt the paste with.
  --language LANGUAGE, -l LANGUAGE
                        (Programming) language of the paste. Default: plaintext
  --expires-after SECONDS, -x SECONDS
                        Number of seconds after which the paste will expire.
  --burn-after-read, -b
                        Delete the paste after it has been read once.Read a pasteusage: yabin read [-h] [--password PASSWORD] URL

positional arguments:
  URL                   Complete URL of the paste to read.

options:
  -h, --help            show this help message and exit
  --password PASSWORD, -p PASSWORD
                        Password to decrypt the paste with. Only needed if password-protected.
Package: yabmp
YABMP=====|Python Version| |Version| |License| |Build Status| |Code Climate|Overview~~~~~~~~`YABMP` is a receiver-side implementation of the `BMP` (BGP Monitoring Protocol) in the Python language. It serves as a reference for how to step through the messages and write their contents to files.This implementation covers RFC 7854 BGP Monitoring Protocol version 3.RFCs to read to help you understand the code better:* RFC1863 - A BGP/IDRP Route Server alternative to a full mesh routing* RFC1997 - BGP Communities Attribute* RFC2042 - Registering New BGP Attribute Types* RFC2858 - Multiprotocol Extensions for BGP-4* RFC4271 - A Border Gateway Protocol 4 (BGP-4)* RFC4893 - BGP Support for Four-octet AS Number Space* Other BGP related RFCs.Quick Start~~~~~~~~~~~.. code:: bashUse `pip install yabmp` or install from source.$ virtualenv yabmp-virl$ source yabmp-virl/bin/activate$ git clone https://github.com/smartbgp/yabmp$ cd yabmp$ pip install -r requirements.txt$ cd bin$ python yabmpd -h.. code:: bash$ python yabmpd &Will starting bmpd server listen to port = 20000 and ip = 0.0.0.0Support~~~~~~~Send email to xiaoquwl@gmail.com, or use GitHub issue system/pull request... |License| image:: https://img.shields.io/hexpm/l/plug.svg:target: https://github.com/smartbgp/yabmp/blob/master/LICENSE.. |Build Status| image:: https://travis-ci.org/smartbgp/yabmp.svg:target: https://travis-ci.org/smartbgp/yabmp.. |Code Climate| image:: https://codeclimate.com/github/smartbgp/yabmp/badges/gpa.svg:target: https://codeclimate.com/github/smartbgp/yabmp.. |Python Version| image:: https://img.shields.io/pypi/pyversions/Django.svg:target: https://github.com/smartbgp/yabbmp.. |Version| image:: https://img.shields.io/pypi/v/yabmp.svg?:target: http://badge.fury.io/py/yabmp
Package: yabormeparser
Yet another BORME Parser.BORME (Boletin Oficial del Registro Mercantil) is the Official Bulletin of the
Commercial Registry.[BORME documents](https://boe.es/diario_borme/)This program translate BORME PDF files to JSON.Borme has two Parsers to extract the PDF file data to a json file.Parser: Read PDF files and write raw json files.Parser2: Read raw json files and write process json files.
Package: yabs
yabsTest, Build, Deliver!OverviewBuild and deployment automation for Python projects.A typical release workflow may look like this:Check preconditions:Is the workspace clean, anything to commit?,Is GitHub reachable?,Are we on the correct branch?, ...Make sure static code linters and unit tests pass.Bump the project's version number (major, minor, or patch, according toSemantic Versioning).Then patch the version string into the respective Python module or text file.Buildsdist,wheelandmsi installerassets.Tag the version, commit, and push.Upload distribution toPyPI.Create a new release onGitHuband upload assets.Create a new release on theWindows Package Manager Repository.Bump, tag, commit, and push for post-release.Custom tasks may be added using the plugin framework.Read the documentationfor details.PreconditionsUsegit,PyPI,
andGitHub.Version numbers follow roughly theSemantic Versioningpattern.The project's version number is maintained inone of the supported locations(Seegrunt-yabsfor a node.js variant
if you have a JavaScript based development stack.)
Package: yabs-cowsay
yabs-cowsayExtension plugin foryabs.This simple example serves primarily as demo for the yabs's plugin architecture.Let's assume we need a new taskcowsaythat is used like so:...-task:cowsaywidth:40message:|Dear fellow cattle,We just released version {version}.(This message was brought to you by the 'yabs-cowsay' extension.)...and produces this output:_________________________________________/Dearfellowcattle,\|Wejustreleasedversion0.0.19-a2.||(Thismessagewasbroughttoyoubythe|\'yabs-cowsay'extension.)/-----------------------------------------\^__^\(oo)\_______(__)\)\/\||----w|||||This plugin also adds a--no-cowsayoption to the CLI.Read the docsfor details.
Package: yabte
yabte - Yet Another BackTesting EnginePython module for backtesting trading strategies.Support event driven backtesting, ieon_open,on_close, etc. Also supports multiple assets.Very basic statistics like book cash, mtm and total value. Currently, everything else needs to be deferred to a 3rd party module likeempyrical.There are some basic tests but use at your own peril. It's not production level code.Core dependenciesThe core module uses pandas and scipy.InstallationpipinstallyatbeUsageBelow is an example usage (the performance of the example strategy won't be good).importpandasaspdfromyabte.backtestimportStrategy,StrategyRunner,Order,Bookfromyabte.utilities.plot.matplotlib.strategy_runnerimportplot_strategy_runnerfromyabte.utilities.strategy_helpersimportcrossoverfromyabte.tests._helpersimportgenerate_nasdaq_datasetclassSMAXO(Strategy):definit(self):# enhance data with simple moving averagesp=self.paramsdays_short=p.get("days_short",10)days_long=p.get("days_long",20)close_sma_short=(self.data.loc[:,(slice(None),"Close")].rolling(days_short).mean().rename({"Close":"CloseSMAShort"},axis=1,level=1))close_sma_long=(self.data.loc[:,(slice(None),"Close")].rolling(days_long).mean().rename({"Close":"CloseSMALong"},axis=1,level=1))self.data=pd.concat([self.data,close_sma_short,close_sma_long],axis=1).sort_index(axis=1)defon_close(self):# create some ordersforsymbolin["GOOG","MSFT"]:df=self.data[symbol]ix_2d=df.index[-2:]data=df.loc[ix_2d,("CloseSMAShort","CloseSMALong")].dropna()iflen(data)==2:ifcrossover(data.CloseSMAShort,data.CloseSMALong):self.orders.append(Order(asset_name=symbol,size=-100))elifcrossover(data.CloseSMALong,data.CloseSMAShort):self.orders.append(Order(asset_name=symbol,size=100))# load some dataassets,df_combined=generate_nasdaq_dataset()# create a book with 100000 cashbook=Book(name="Main",cash="100000")# run our strategysr=StrategyRunner(data=df_combined,assets=assets,strat_classes=[SMAXO],books=[book],)sr.run()# see the trades or book historyth=sr.transaction_historybch=sr.book_history.loc[:,(slice(None),"cash")]# plot the trades against book valueplot_strategy_runner(sr);ExamplesJupyter notebook examples can be found under thenotebooks folder.DocumentationDocumentation can be found onRead the Docs.DevelopmentBefore commit run following format commands in project folder:poetryrunblack.
poetryrunisort.--profileblack
poetryrundocformatter.--recursive--in-place--black--exclude_unittest_numpy_extensions.py
Package: yabu
YABUyet another backup utilityYABUis a utility that exploitingrsyncallows to automatize backup tasks also for remote servers.InstallYABUrequired to work thersynctool, you can easily retrieves it from your package manager:From AUR (recommended if you using Arch Linux)YABUis available also asAURpackage. Yuo can find it aspython-yabu.From pypi (recommended)You can installYABUfrompypiusingpip.pipinstallyabuFrom source codeAn alternative way to installYABUis from the source code, exploiting thesetup.pyscript.gitclonehttps://github.com/RobertoBochet/yabu.gitcdyabu
python3setup.pyinstall--userUsageyabu-husage: yabu [-h] [-c CONFIG_PATH] [-v] [--version]

optional arguments:
  -h, --help            show this help message and exit
  -c CONFIG_PATH, --config CONFIG_PATH
                        configuration file path
  -v                    number of -v defines level of verbosity
  --version             show program's version number and exitBefore startYABUyou must create a custom configuration file (see configuration section).ConfigurationThe wholeYABUbehaviour can be configured with itsconfig.yaml.
You can provide toYABUa custom configuration file exploiting argument-c, if you will not do it,YABUwill look for it in the default path/etc/yabu/config.yaml.config.yamlstructuretasks[dict<string,dict>]is a dict of the tasks that will be done, each task has a custom name as key and it has a specific structremote_base_path[string]the base path of the remote servertargets[list<string>]a list of the paths that have to be backupedA complete schema of config file can be found inyabu/resources/config.schema.yaml.
Package: yabul
yabulYet Another Bioinformatics Utilities LibraryThis is a small collection of Python functions for working with protein, DNA,
and RNA sequences. We usepandasdata frames
wherever possible.Yabul currently supports:Reading and writing FASTAsPairwise local and global sequence alignment (usesparasail)Requires Python 3.6+.InstallationInstall using pip:$ pip install yabulYou can run the unit from a checkout of the repo as follows:$ pip install pytest
$ pytestExampleReading and writing FASTAsTheread_fastafunction returns apandas.DataFrame:>>> import yabul
>>> df = yabul.read_fasta("test/data/cov2.fasta")
>>> df.head(3)
                                                             description                                           sequence
id
sp|P0DTC2|SPIKE_SARS2  sp|P0DTC2|SPIKE_SARS2 Spike glycoprotein OS=Se...  MFVFLVLLPLVSSQCVNLTTRTQLPPAYTNSFTRGVYYPDKVFRSS...
sp|P0DTD1|R1AB_SARS2   sp|P0DTD1|R1AB_SARS2 Replicase polyprotein 1ab...  MESLVPGFNEKTHVQLSLPVLQVRDVLVRGFGDSVEEVLSEARQHL...
sp|P0DTC1|R1A_SARS2    sp|P0DTC1|R1A_SARS2 Replicase polyprotein 1a O...  MESLVPGFNEKTHVQLSLPVLQVRDVLVRGFGDSVEEVLSEARQHL...Thewrite_fastafunction takes
(name, sequence) pairs:>>> yabul.write_fasta("out.fasta", [("protein1", "TEST"), ("protein2", "HIHI")])
>>> yabul.write_fasta("out2.fasta", df.sequence.items())Sequence alignmentThealign_pairfunction will give a local (Smith-Waterman) and global
(Needleman-Wunsch) alignment of two sequences. It returns a pandas.Series
with the aligned sequences.By default, the alignment is global:>>> yabul.align_pair("AATESTDD", "TEST")
query             AATESTDD
reference         --TEST--
correspondence      ||||
score                   -5
dtype: objectTo do a local alignment, passlocal=True.>>> yabul.align_pair("AATESTDD", "TEST", local=True)
query             TEST
reference         TEST
correspondence    ||||
score               19
dtype: objectDependenciesThe alignment routine is a thin wrapper around the Smith-Waterman and
Needleman-Wunsch implementations fromparasail.ContributingWe welcome contributions of well-documented code to read and write common
bioinformatics file formats using pandas objects. Please include unit tests
in your PR. Additional functionality like multiple sequence alignment would
also be nice to add.ReleasingTo push a new release to PyPI:Make sure the package version specified in__init__.pyis a new version greater than what's onPyPI.Tag a new release on GitHub matching this versionTravis should deploy the release to PyPI automatically.Documentation athttps://yabul.readthedocs.io/en/latest/should update automatically on commit.To build the documentation locally, run:$ cd docs
$ pip install -r requirements.txt
$ sphinx-build -b html . _build
Package: yac
A service, running on your VPC, from nothing to ka-ching, in a few minutes.Have access to an AWS VPC?Want to run a service on your VPC?Have a few spare minutes?Why yac?Because services provided by cloud providers are expensive (e.g. RDS, ElasticCache, etc.).Yac lets you build and share comparable services, effectively crowd-sourcing their evolution.Yac also lets you build service heirarchies (so, for example, a yac blogging service can levage a yac DB service, etc.).Over time, durable service patterns should survive and thrive, and service providers will be able to choose from a rich menu of open, crowd-sourced, and crowd-supported services.How does yac work?Coding infrastructure is all about managing templates and template varariables.YAC makes it easy to create templates and blend variables from multiple sources, including from user prompts.The resulting infrastruce code can be easily shared with other service providers, allowing others to use and improve on your infrastructure ideas.Yac lets you use code in your templates - this provides great power and flexibility to service designers.Yac uses simple cli operations and infrastructure is specified in json files, making CI/CD intergration a breeze.Quick StartInstall the cli:$ pip install yacFind a service:$ yac service –find=confluencePrint a service:$ yac stack atlassian/confluenceWhat is yac?A workflow system that does for services what docker did for applicationsdocker helped make it easy to find, run, define, and share individual applicationsyac does the same for servicesA cli app that lets you easily find, run, define, and share service templatesyac registry works just like the docker registryservices are defined as templates in jsonservices templates can be browsed, and instantiated via the yac registryA happy place for service developers, cloud administrators, and service providersWhat is a service?An application that provides some useful functionAn application that can be implemented using cloud infrastructureIntruiged?Read more atyac stackson atlassian.net.Want to contribute?Run Locallyrun …
./yacme <cmd> <servicefile>Buildingrun …./build.pyTestingGet unit tests to pass$ python -m unittest discover yac/tests
Package: yace
Welcome to yaceyaceis a foreign-function-interface (FFI) compiler designed to ease the
development and maintenance of C APIs, their libraries and the
FFI-bindings/wrappers using them.The project is hosted onGitHUBDocumentation is available atsafl.dk/yaceyaceis a new project, with a bunch of things it want to get done, why?
Because there are some projects that need a better way to handle C headers and
libraries bindings. If you want to help out, then don’t be shy, there are
plenty of things to do.
Package: yacedar
python-yacedarSimple, straitforward Python bindings for RustCedar policy language.InstallationpipinstallyacedarUsageSee/sampledirectory.'''1. Policy structurehttps://www.cedarpolicy.com/en/tutorial/policy-structure'''importyacedarpolicy_set=yacedar.PolicySet('''\permit(principal == User::"alice",action    == Action::"update",resource  == Photo::"VacationPhoto94.jpg");''')request=yacedar.Request(principal=yacedar.EntityUid('User','alice'),action=yacedar.EntityUid('Action','update'),resource=yacedar.EntityUid('Photo','VacationPhoto94.jpg'),)authorizer=yacedar.Authorizer()response=authorizer.is_authorized(request,policy_set)# expected: Trueprint(response.is_allowed)
Package: yacgol
Yet Another Conway's Game of Lifeyacgolis a pure Python implementation ofConway's Game of LifeusingTkinter.The game is a zero-player game, meaning that its evolution is determined
by its initial state, requiring no further input. One interacts with the
Game of Life by creating an initial configuration and observing how it
evolves, or, for advanced players, by creating patterns with particular
properties.At each step in time, the following transitions occur:Any live cell with fewer than two live neighbors dies, as if by under population.Any live cell with two or three live neighbors lives on to the next generation.Any live cell with more than three live neighbors dies, as if by overpopulation.Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.Conway's Game of Life Wikipedia pageInstalling$ pip install yacgol
$ yacgol -hUsingMost interactions withyacgolwill take place within the Tkinter UI. So
fire upyacgoland check it out!DevelopingFirst, install development packages:$ pip install -r requirements-dev.txtTesting$ nose2Linting$ flake8Coverage$ nose2 --with-coverage
Package: yachain
YAML access on chained attribute names.Install$pipinstallyachainSuppose we have:---# confignetwork:name:developersgitserver:ip:192.168.178.101netmask:255.255.255.0gateway:192.168.178.1packages:-yum-gccWithyachainwe can access this as:>>>importyachain>>>c=yachain.Config().load("netw.cfg")>>>print(c["network::gitserver::gateway"])192.168.178.1>>>print(c["network::gitserver::packages"])['yum','gcc']References to files / paths independent from environmentReferences to files and paths can be used relative and absolute.
In case an attribute ends onpathorfilethen the path can be
prefixed automatically when operation from a virtual environment is detected.
The works by default upper and lower case and can be overriden.Using theprefixmakes it possible to use the same config in different
environments.importyachainimportyamlimportsysimportos# yaml config:yc="""
---
app:
  logfile: var/log/app.log
  textrules: var/app.app.txt
  database_path: var/app/db
  database_file: /var/app/db/db.txt
  database_name: db.txt
"""PREFIX="/"ifnothasattr(sys,'real_prefix')elsesys.prefix# CONFIG_FILE = os.path.join(PREFIX, "etc/app/app.cfg")config=yachain.Config(prefix=PREFIX,configdata=yaml.load(yc))forAin["logfile","textrules","database_path","database_file","database_name"]:k="app::{}".format(A)printconfig[k]When run from a virtual environment, this will give us:/home/user/venv/var/log/app.logvar/app.app.txt/home/user/venv/var/app/db/var/app/db/db.txtdb.txtSo, as expected, thelogfileanddatabase_pathgot the PREFIX.When run from a non-virtual environment, this will give us:/var/log/app.logvar/app.app.txt/var/app/db/var/app/db/db.txtdb.txtSo, as expected, prefixed with “/”.
Package: yacho
yachoThe static site generator for creative coders.Demo pageDemo page:https://yacho-demo.netlify.app/Repository:https://github.com/eqs/yacho-exampleRequirementsPython 3.7+Installationpip install yachoUsageDirectory Structure.
│  avatar.png
│  custom.css
│  yacho.sketchbook.toml    <----------- Put PROJECT config file
│
├─sketch_210401a
│  │  sketch_210401a.pde
│  │  yacho.sketch.toml    <----------- Put sketch config file
│  │
│  ├─cover
│  │      cover_image.png
│  │
│  └─images
│          img1.png
│          img2.png
│          img3.png
│          ...
│
└─sketch_210402a
    │  sketch_210402a.pde
    │  yacho.sketch.toml    <----------- Put sketch config file
    │
    ├─cover
    │      cover_image.png
    │
    └─images
            img1.png
            img2.png
            img3.png
            ...Build site# v0.0.2+
yacho build

# v0.0.1
# yacho yacho.sketchbook.tomlPushdistto your gh-pages.Sketch generatorProcessing sketchyacho createp5.js sketchyacho create -t p5jsExampleyacho.sketchbook.tomlsketchbook_root='.'base_url='https://yacho-demo.netlify.app/'# Page titletitle='My Sketchbook'# Profile informationauthor='eqs'avatar='chi.png'# relative path from sketchbook_rootbio="""Creative Coder"""# Your custom css (relative path from sketchbook_root)custom_css='custom.css'[social]home="https://www.eqseqs.work"twitter="eqs_work"github="eqs"instagram=""youtube=""facebook=""Exampleyacho.sketch.toml# If title is empty, sketch dir name will be used as title.title="Flowers"# Default to falsedraft=falsecomment="An example comment."# Files listed in this value will be public.# Default to:public=['*.pde','sketch.js','*.py']# video embedding will be available v0.0.2[video]# Please set 'none', 'youtube', 'vimeo', 'neort' or 'gif'type='none'# If you use 'gif', id will be interpreted as file path of gif animation.id=''
Package: yacht
yachtYAML conversion to HTMLWhilst static web pages are less popular nowadays, this project aims to simplify(?) their creation by using a more human friendly markup language.No more searching for unterminated tags and improved readability - thanks to YAML's indented structureRequirementsunsurprisingly, you need the PyYAML package, to process the YAML filesUsage:for now you can run it as:python3 -m yacht.convert input.yaml > output.htmlpropper support for parameters will be added soon
Package: yaci
Yet Another Cache ImplementationSo you may be asking "Is there really a need for yet another cache
implementation?" I mean we already have:functools.lru_cache (Python 3.2 or greater)- Decorator to wrap a function with a memoizing callable that saves up to the maxsize most recent calls.thememoize patternpymemcache- A comprehensive, fast, pure-Python memcached clientDiskCache- An Apache2 licensed disk and file backed cache library, written in pure-Pythonminicache- Python memory caching utilities for Python 2 and 3 versions, also PyPy.pylibmc- A Python wrapper around the libmemcached interface from TangentOrg.thememento pattern- a way of saving stateThe answer is no, there are plenty of caching libraries and patterns out
there and yet another one isn't necessary, so with that being said,
here isYetAnotherCachingInterface.MotivationI needed a caching interface that allowed me to change or implement
different storage backends as needed. I also wanted a caching implementation whose interface closely resembled the Pythoncollections.MutableMappinginterface, so that I could easily switch between dictionaries and other storage backends.Installing as apipTo install the package run:pip install yaciDeveloping Using DockerThe docker directory contains a Dockerfile that can be used to build a docker image which can be used for development. See the README.md in the docker directory for more help.Using PipenvIf you'd like to use Pipenv to mange this package in a development environment just run the commandpipenv installin the top level of the repository.
Package: yacine-47-rocket
package_namepackage_nameis a Python library for ..........InstallationUse the package managerpipto installpackage_name.pipinstallpackage_nameUsageimportpackage_name# returns 'words'package_name.module_name('word')# returns 'geese'package_name.module_name('goose')# returns 'phenomenon'package_name.module_name('phenomena')LicenseMIT
Package: yacli
$ yacli_# Install## Pip`sudo apt-get install python-pip python-dev build-essential``sudo pip install --upgrade pip`## Dependency`sudo pip install requirement.txt`## Yacli`sudo pip install --editable .`## Actito homeACTITO__HOME variable is used to define the directory where all actito projectsare.Add `export ACTITO_HOME=~/path/to/actito/directory` in your .bashrc, .zshrc or.profile.# Usage## List of commands`yacli`## Detail for a command`yacli CMD --help`
Package: ya-client-payment
Invoicing and Payments is a fundamental area of Yagna Ecosystem functionality. It includes aspects of communication between Requestor, Provider and a selected Payment Platform, which becomes crucial when Activities are executed in the context of negotiated Agreements. Yagna applications must be able to exercise various payment models, and the Invoicing/Payment-related communication is happening in parallel to Activity control communication. To define functional patterns of Requestor/Provider interaction in this area, Payment API is specified.  An important principle of the Yagna Payment API is that the actual payment transactions are hidden behind the Invoice flow. In other words, a Yagna Application on Requestor side isn’t expected to trigger actual payment transactions. Instead it is expected to receive and accept Invoices raised by the Provider - based on Application’s Invoice Accept notifications, the Payment API implementation orchestrates the payment via a configured Payment platform.NOTE: This specification is work-in-progress.# noqa: E501