Saravanan666/pypi-org huggingface dataset:
Package: alouette
Alouette(Y-ETanother encapsulaTEd TA-UOLA, backwards)DescriptionAlouette is aTAUOLAthin wrapper for simulating single τ decays.
It can operate in forward or inbackward Monte Carlomode.  Alouette is
built overTauola++Fortran source (version 1.1.8, for LHC). It can
be used as a C library (libalouette) or as a Python 3 package
(alouette).The Alouette API is meant to be light and simple. It exposes two key functions,decayandundecay.  Initialisation is automatic.  A more detailed
description of Alouette is avaible online, fromRead the Docs.
One can also browse theexamplesshipped with thesource.PortabilityAlouette is designed for UNIX systems. It relies on POSIX specifics, e.g.  it
assumes/dev/urandomto be available. Alouette is tested onLinuxandOSX.Thread safetyTAUOLA and the Alouette wrapper donotsupportmulti-threading.LicenseThe Alouette wrapper is  under theGNU LGPLv3license. See theLICENSEandCOPYING.LESSERfiles.
Package: aloy
AloyThe content of this repository is currently under development. Eventually, the aim is that this repository will contain a comprehensive suite of algorithms and data structures for artificial intelligence, machine learning, and autonomous robots.Current IdeasLead-lag compensators for controllers,Control system demonstration and testing GUI,Reimplement master's thesis design, but better!Genetic algorithms;Support variable length chromosomes,Support multiple-chromosomes.Particle swarm optimisation,The Bees algorithm,Optimisation test functions,Optimisation error surface plotting,Optimisation process viewer GUI,General reinforcement learning API,Try Rayhttps://github.com/ray-project/rayandhttps://docs.ray.io/en/latest/rllib/index.html, and cleanRLhttps://github.com/vwxyzjn/cleanrl.General deep game tree and MCTS API,New event flow and command flow system with pub-sub style pattern for GUIs,New threadpool system and futures implementation,New thread-safe queues implementation,Snake game with GUI and RL,Support saving options and highscores,Support recoding games for use as replay and for immitation learning.Tetris game with GUI, curses, and RL,Inspiration for GUIhttps://github.com/janbodnar/PyQt6-Tutorial-Examples,https://doc.qt.io/qt-6/qtwidgets-widgets-tetrix-example.html, andhttps://gitpress.io/u/1155/pyqt-example-tetrix,Inspiration for curseshttps://github.com/cSquaerd/CursaTetra,https://github.com/orodley/curses-tetris/blob/master/main.py,https://codereview.stackexchange.com/questions/249326/python-3-curses-terminal-tetris,https://gitlab.com/mkhCurses/tetris-curses-python,https://github.com/adrienmalin/Terminis/tree/master.Pacman game with GUI and RL,Connect four game with GUI and deep game trees;Take inspiration fromhttp://blog.gamesolver.org/andhttps://github.com/PascalPons/connect4.Support playing over socket connection.Block breaker game using PyGame,Control interface for robots,Control and path planning simulator GUI for robots,More efficient data holders and multi-table data holders that you can attach to other classse and objects to capture performance statistics,Benchmarking tools.
Package: alpa
Documentation|SlackAlpa is a system for training and serving large-scale neural networks.Scaling neural networks to hundreds of billions of parameters has enabled dramatic breakthroughs such as GPT-3, but training and serving these large-scale neural networks require complicated distributed system techniques.
Alpa aims to automate large-scale distributed training and serving with just a few lines of code.The key features of Alpa include:💻Automatic Parallelization. Alpa automatically parallelizes users' single-device code on distributed clusters with data, operator, and pipeline parallelism.🚀Excellent Performance. Alpa achieves linear scaling on training models with billions of parameters on distributed clusters.✨Tight Integration with Machine Learning Ecosystem. Alpa is backed by open-source, high-performance, and production-ready libraries such asJax,XLA, andRay.ServingAlpa provides a free, unlimited OPT-175B text generation service.
Try the service athttps://opt.alpa.ai/and share yourprompting results!The code below shows how to use huggingface/transformers interface and Alpa distributed backend for large model inference.
Detailed documentation is inServing OPT-175B using Alpa.fromtransformersimportAutoTokenizerfromllm_serving.model.wrapperimportget_model# Load the tokenizertokenizer=AutoTokenizer.from_pretrained("facebook/opt-2.7b")tokenizer.add_bos_token=False# Load the model. Alpa automatically downloads the weights to the specificed pathmodel=get_model(model_name="alpa/opt-2.7b",path="~/opt_weights/")# Generateprompt="Paris is the capital city of"input_ids=tokenizer(prompt,return_tensors="pt").input_idsoutput=model.generate(input_ids=input_ids,max_length=256,do_sample=True)generated_string=tokenizer.batch_decode(output,skip_special_tokens=True)print(generated_string)TrainingUse Alpa's decorator@parallelizeto scale your single-device training code to distributed clusters.
Check out thedocumentationsite andexamplesfolder
for installation instructions, tutorials, examples, and more.importalpa# Parallelize the training step in Jax by simply using a decorator@alpa.parallelizedeftrain_step(model_state,batch):defloss_func(params):out=model_state.forward(params,batch["x"])returnjnp.mean((out-batch["y"])**2)grads=grad(loss_func)(model_state.params)new_model_state=model_state.apply_gradient(grads)returnnew_model_state# The training loop now automatically runs on your designated clustermodel_state=create_train_state()forbatchindata_loader:model_state=train_step(model_state,batch)Learning morePapersGoogle AI blogOSDI 2022 talk slidesICML 2022 big model tutorialProf. Ion Stoica introduces the systemGetting InvolvedConnect to Alpa developers via theAlpa slack.Please read thecontributor guideif you are interested in contributing code.LicenseAlpa is licensed under theApache-2.0 license.
Package: alpaca
# alpaca
将一个描述词法的正则表达式转换成最小化的DFA，以dot语言形式输出。# llama
将描述语法的范式转换成分析转换表，以图形的方式输出，同时能够根据不同的语法分析算法检查范式的定义错误，并且能够修正错误。详情请参考[alpace-llama wiki](https://github.com/activesys/alpaca-llama/wiki)。
Package: alpaca-backtrader-api
alpaca-backtrader-apialpaca-backtrader-apiis a python library for the Alpaca trade API
withinbacktraderframework.
It allows rapid trading algo development easily, with support for the
both REST and streaming interfaces. For details of each API behavior,
please see the online API document.Note this module supports only python version 3.5 and above, due to
the underlying libraryalpaca-trade-api.Install$pip3installalpaca-backtrader-apiExampleThese examples only work if you have a funded brokerage account or another means of accessing Polygon data.you can find example strategies in thesamplesfolder.remember to add you credentials.you can toggle between backtesting and paper trading by changingALPACA_PAPERa strategy looks like this:In order to call Alpaca's trade API, you need to obtain API key pairs.
Replace <key_id> and <secret_key> with what you get from the web console.importalpaca_backtrader_apiimportbacktraderasbtfromdatetimeimportdatetimeALPACA_API_KEY=<key_id>ALPACA_SECRET_KEY=<secret_key>ALPACA_PAPER=TrueclassSmaCross(bt.SignalStrategy):def__init__(self):sma1,sma2=bt.ind.SMA(period=10),bt.ind.SMA(period=30)crossover=bt.ind.CrossOver(sma1,sma2)self.signal_add(bt.SIGNAL_LONG,crossover)cerebro=bt.Cerebro()cerebro.addstrategy(SmaCross)store=alpaca_backtrader_api.AlpacaStore(key_id=ALPACA_API_KEY,secret_key=ALPACA_SECRET_KEY,paper=ALPACA_PAPER)ifnotALPACA_PAPER:broker=store.getbroker()# or just alpaca_backtrader_api.AlpacaBroker()cerebro.setbroker(broker)DataFactory=store.getdata# or use alpaca_backtrader_api.AlpacaDatadata0=DataFactory(dataname='AAPL',historical=True,fromdate=datetime(2015,1,1),timeframe=bt.TimeFrame.Days)cerebro.adddata(data0)print('Starting Portfolio Value:%.2f'%cerebro.broker.getvalue())cerebro.run()print('Final Portfolio Value:%.2f'%cerebro.broker.getvalue())cerebro.plot()API DocumentThe HTTP API document is located inhttps://docs.alpaca.markets/AuthenticationThe Alpaca API requires API key ID and secret key, which you can obtain from the
web console after you sign in.  You can set them in the AlpacaStore constructor,
using 'key_id' and 'secret_key'.Paper/Live modeThe 'paper' parameter is default to False, which allows live trading.
If you set it to True, then you are in the paper trading mode.Running Multiple Strategies/DatasThere's a way to execute an algorithm with multiple datas or/and execute more than one algorithm.The websocket connection is limited to 1 connection per account. Alpaca backtrader opens a websocket connection for each data you define.For that exact purpose thiswas createdThe steps to execute this are:Run the Alpaca Proxy Agent as described in the project's READMEDefine this env variable:DATA_PROXY_WSto be the address of the proxy agent. (e.g:DATA_PROXY_WS=ws://192.168.99.100:8765)execute your algorithm. it will connect to the servers through the proxy agent allowing you to execute multiple datas/strategiesSupport and ContributionFor technical issues particular to this module, please report the
issue on this GitHub repository. Any API issues can be reported through
Alpaca's customer support.New features, as well as bug fixes, by sending pull request is always
welcomed.
Package: alpaca-isp
In-system programming tool for LPC microcontrollersFeaturesProvides a Pythonic interface to the LPC ISP command handlerCan put microcontrollers into ISP mode by manipulating the serial port’s DTR
(/RST) and RTS (/ISP) linesConvenient command-line interface for flashing from build systemsRequirementsPython 3.6 (probably works with older versions of Python 3, but untested)PySerial >= 3.4IntelHex >= 2.1
Package: alpaca-lumnis-trader
AlpacaLumnisTraderAPI UsageInstall the packagepip3 install alpaca-lumnis-trader --upgradeOverriding the run functionOverriding the main functionDevelopment UsageFork the repoGo to the follwing link to fork the repository:https://github.com/lumnisfactors/AlpacaLumnisTrader.gitClone the RepoUse the following command to clone the repository:git clone https://github.com/[YOUR_USERNAME]/AlpacaLumnisTrader.gitInstall RequirementsAfter cloning the repository, navigate to the project's root directory and install the required packages using the following command:pip install -r requirements.txtAdd API KeysCreate a new file in the AlpacaLumnisTrader directory and name it KEYS.py. Add the following variables to the file and replace the empty strings with your respective API keys:API_KEY_ALPACA = "YOUR_ALPACA_API_KEY"
SECRET_KEY_ALPACA = "YOUR_ALPACA_SECRET_KEY"
API_KEY_LUMNIS = "YOUR_LUMNIS_API_KEY"These API keys are required for using Binance and Luminis data to make trades. Please ensure that you keep your API keys secret and never share them with anyone.
Package: alpaca-ml
alpaca.. image::https://raw.githubusercontent.com/stat-ml/alpaca/master/images/alpaca.pngPackage for active learning and uncertainty quantification in neural nets.InstallationYou can install the package via pip.. code-block:: bashpip install alpaca-mlCode examplesTutorial are available as example notebooks inexamplesfolder.Uncertainty for classification taskUncertainty for regression taskActive learning on regressionUncertainty visualization
Package: alpaca-prov
alpacaAutomated Lightweight Provenance CaptureAlpaca is a Python package for the capture of provenance information during the
execution of Python scripts that process data.Alpaca provides a simple API for recording the details of the functions being
executed, the data flow, and a description of parameters used.
This is accomplished with minimal code instrumentation and user intervention.Provenance information is structured and serialized according to a model
based on theW3C PROV format.Table of contentsPrerequisitesInstallationDocumentationHow to runCollaboratorsHow to contributeGet supportAcknowledgmentsLicenseCopyrightPrerequisitesRequirementsAlpaca requires Python 3.8 or higher and the packages specified inrequirements.txt.InstallationUse the package managerpipto install Alpaca.Package onpypipipinstallalpaca-provMore detailed instructions on how to setup conda environments and additional
install options can be checked in theInstallationpage.DocumentationSeehttps://alpaca-prov.readthedocs.io/en/latest/.How to runExamples showing how to use Alpaca can be found in theexamplesfolder. Detailed instructions on how to set up and run arehere.ColaboratorsAll the contributors to the development of Alpaca can be found in theAuthors and contributorspage.How to contributeIf you want to suggest new features, changes, or make a contribution, please
first open an issue on theproject page on GitHubto discuss your idea.Pull requests are welcome. Any contribution should also
be covered by appropriate unit tests in thetestsfolder.Get supportIf you experience any issue or wish to report a bug, please open an issue on
theproject page on GitHub.AcknowledgmentsSeeacknowledgments.LicenseBSD 3-Clause License, seeLICENSE.txtfor details.Copyright:copyright: 2022-2023, Forschungszentrum Jülich GmbH, INM-6, IAS-6. All rights reserved.
Package: alpaca-trading-algorithm
Hello, welcome to tradingalgorithm, a Python package for easy algorithmic trading on AlpacaThis package allows one to check account status, make long orders, make short orders, run a custom momentum-based algorithm, and automatically calculate the best tickers to trade in the S&P500 based off of probability of returns and betas.To run this package, you will need an IEX Finance key, as well as an Alpaca API keyTo install the algorithm:$ pip install alpaca-trading-algorithmTo pick a stock ticker:from alpaca_trading_algorithm import tickerpicker

ticker = tickerpicker.tickerpicker()To create a stock class:from alpaca_trading_algorithm import trader

ticker = 'AAPL'

aapl = trader.stock(alpacaKey, alpacaSecretKey, iexKey, ticker)Methods in the class:aapl.position()
# output: Number of shares:  
#         Market Value: 
#         Profit/Loss: 

aapl.checkhours()
# output: The market is (open or close)Returns maximum amount of shares that you can trade of the ticker based on market value of cash portfolioaapl.max_shares()Takes AAPL (or chosen ticker) long at the current market price and specified share amountaapl.longmarket(shares)Takes AAPL (or chosen ticker) long at the current close of the stockaapl.longlimit(shares)Takes AAPL (or chosen ticker) short at the current market priceaapl.short(shares)Closes entire short or long position in AAPL (or chosen ticker) based on whether you specify "long" or "short" as the typetocloseaapl.closeposition(typetoclose)Runs a momentum algorithm ONE TIME based on volume and time&sales, will take a stock short, long, close position, re-position, and employs a custom stop-lossaapl.algo()Runs the same momentum algorithm CONTINUOUSLY for the set amount of minutesaapl.trade(minutes)
Package: alpacloud-ansible-builder
alpacloud-ansible-builderThis tool automatically builds and installs Ansible Collections.This is useful for testing out purpose built collections. It's also nice for testing collections. I think it's most useful for repositories with collections alongside deployments:- collections
	- our_monitoring
- deployments
	- our_monitoring_staging
	- our_monitoring_team_0
	- our_monitoring_team_1
	- our_monitoring_team_2usageThe Ansible builder can be used to build all collections in a directory:alpacloud-ansible-builder.It can also be used to watch collections for changes and rebuild them.alpacloud-ansible-builder--watch.The--debounceoption lets you customise the time between the last change happening to a collection and a build being triggered.
Package: alpaqa
alpaqaAlpaqais an efficient implementation of the Augmented Lagrangian method for general nonlinear programming problems,
which uses the first-order, matrix-free PANOC algorithm as an inner solver.The numerical algorithms themselves are implemented in C++ for optimal performance,
and they are exposed as an easy-to-use Python package.The solvers in this library solve minimization problems of the following form:The objective functionf(x) and the constraints functiong(x)
should have a Lipschitz-continuous gradient.DocumentationSphinx documentationDoxygen documentationPython examplesC++ examplesInstallationThe project is available onPyPI:python3-mpipinstallalpaqaFor more information, please see the fullinstallation instructions.
Package: alpezacassette
Cassette.Utilidad para pasar guiones escritos enFountaina audio.Ejemplos de uso:Cargamos un fichero de guión en formatoFountaincst="corto"fountain="corto.fountain"salida="$(pwd)/corto"cassetterun-jload-p"pname=$cst"-p"fountain=$fountain"Describimos el guión:cassetterun-jdescribe-p"pname=$cst"Obtenemos el timeline y lo completamos que las pistas que enlazan escenascassetterun-jgettimeline-p"pname=$cst.cst"Se puede pasar una plantillajinja2para que se genere el timeline. Por ejemplo una como la siguiente:cassetterun-jgettimeline-p"pname=$cst.cst"-p"useDefault=path/to/jinjatemplate.yaml"tags:intro:/Dropbox/draft/Gymnopedie.wavbackground:/Dropbox/draft/Gymnopedie.wavend:/Dropbox/draft/Gymnopedie.wavtransition:/Dropbox/draft/Gymnopedie.wavcharacters:-id:1voice:tts:voiceid:14filter:-delay:delay_seconds:0.1-reverb:room_size:0.5-id:2voice:tts:voiceid:14filter:-reverb:room_size:0.1-id:3voice:tts:voiceid:29filter:-reverb:room_size:0.1timeline:-type:soundtrack:introduration:8volume:inout{%- for scene in scenes %}# {{ scene.location }}-type:scenescene_id:{{scene.scene_id}}background:background{%- if not loop.last %}# ...-type:soundtrack:transitionduration:8volume:inout{%- endif %}{%endfor %}-type:soundtrack:endduration:8volume:inoutvideo:{%- for dialogue in dialogues %}# {{ dialogue.SceneID }} {{ dialogue.CharacterName }}:# {{ dialogue.FirstWords }} ...-id:{{dialogue.DialogueID}}type:imageimagePath:/Users/alvaroperis/Dropbox/draft/f9/y1.jpeg{%endfor %}Cargamos el timeline al proyectocassetterun-jloadtimeline-p"pname=$cst"-p"timeline=$cst.cst.yaml"Renderizamos los dialogoscassetterun-jrenderaudio-p"pname=$cst"-p"storepath=$salida"Renderizamos las escenascassetterun-jrenderscene-p"pname=$cst"-p"storepath=$salida"Renderizamos el guión completo.cassetterun-jrenderrecord-p"pname=$cst"-p"storepath=$salida"Renderizado de videocassetterun-jrendervideo-p"pname=$cst"-p"storepath=$salida"-p"audiopath=$salida/film/$cst.mp3"Configuración del timeline.VocesA cada caracter identificado por un id se le puede configurar una voz envoice.tts.voiceid. Adicionalmete a esta voz se le pueden añadir efectos de audio en la secciónfilter.Estos efectos de audio son algunos de los que ofrece la libreriaSpotify Pedalboard.Se tienen disponibles los siguientes:Reverbfilter:...- reverb:room_size:0.5damping:0.5wet_level:0.33dry_level:0.4width:1.0freeze_mode:0.0Distorsionfilter:...- distortion:drive_db:25Delayfilter:...- delay:delay_seconds:0.5feedback:0.0mix:0.5Gainfilter:...- gain:gain_db:1.0EJEMPLO:characters:# PEDRO-id:1voice:tts:voiceid:14filter:-delay:delay_seconds:0.5-distortion:drive_db:25-reverb:room_size:0.1# MARIA-id:2voice:tts:voiceid:29filter:-reverb:room_size:0.1VocesLa voz se ha de setear con el id. El id puede variar según sistema operativo.  Para MACOS es el > siguiente:GeneroIDNombreLenguaVoiceGenderFemale29Monica['es_ES']VoiceGenderFemale31Paulina['es_MX']VoiceGenderFemale37Tessa['en_ZA']VoiceGenderMale14Jorge['es_ES']VoiceGenderMale15Juan['es_MX']VoiceGenderMale8Diego['es_AR']TimelineEscena-type:scenescene_id:1background:bgTransición-type:soundtrack:sound1duration:8volume:inout
Package: alpha2aleph
=======alpha2aleph=======alpha2aleph by suizokukan (suizokukan AT orange DOT fr)Note : this Python3 project can't be used with python2.project's purpose=================A GPLv3/Python3/CLI project to convert something like 'mlḵ' in 'כלמ'.installation============$ pip3 install alpha2alephmore====see README.md file ("how to use" section)see https://github.com/suizokukan/alpha2aleph
Package: alpha2fasta
The alpha2fasta library can be used to encode texts written in natural language to a FASTA-based format. The purpose of coding is to enable the application of various bioinformatics tools in text mining.InstallationYou can install alpha2fasta throughpip:pip install alpha2fastaTested PlatformsPython:3.7.4Windows (64bit):10Required external librariesnumpyunidecodeFunctionsAMINOcode(text,simplified=False)AMINOcode_reverse(coded_text,simplified=False)DNAbits(text)DNAbits_reverse(coded_text)
Package: alpha-automl
Alpha-AutoML is an AutoML system that automatically searches for models and derives end-to-end pipelines that read,
pre-process the data, and train the model. Alpha-AutoML leverages recent advances in deep reinforcement learning and is
able to adapt to different application domains and problems through incremental learning.Alpha-AutoML provides data scientists and data engineers the flexibility to address complex problems by leveraging the
Python ecosystem, including open-source libraries and tools, support for collaboration, and infrastructure that enables
transparency and reproducibility.This repository is part of New York University's implementation of theData Driven Discovery project (D3M).DocumentationDocumentation is availablehere.InstallationThis package works with Python 3.6+ in Linux, Mac, and Windows.You can install the latest stable version of this library fromPyPI:pip install alpha-automlTo install the latest development version:pip install git+https://github.com/VIDA-NYU/alpha-automl@develTrying it using DockerWe provide pre-built docker images with Jupyter and Alpha-AutoML pre-installed that you can use to quickly test Alpha-AutoML.
To test it, you can run the following command in your machine, and open Jupyter Notebook on your browser:docker run -p 8888:8888 ghcr.io/vida-nyu/alpha-automlUsing this command, Jupyter Notebook will auto-generate a security token. The correct URL to access the Jupyter will be printed in the console output and will look like:http://127.0.0.1:8888/?token=70ace7fa017c35ba0134dc7931add12bf55a69d4d4e6e54f.Alternatively, if you want to provide a custom security token, you can run:docker run -p 8888:8888 -e JUPYTER_TOKEN="<my-token>" ghcr.io/vida-nyu/alpha-automlIf you are running the Jupyter Notebook in a secure environment, the authentication can be disabled as follows:docker run -p 8888:8888 ghcr.io/vida-nyu/alpha-automl --NotebookApp.token=''Building a Docker image from scratchIf you need to build an image from sources, you can use ourDockerfile. You can use a docker-build argument to select the packages that will be installed in the image (e.g.,full,timeseries,nlp, etc) as follows:docker build -t alpha-automl --build-arg BUILD_OPTION=full .Or simply a base version using (this will use less disk space but will not provide support for some tasks such as NLP and timeseries):docker build -t alpha-automl:latest --target alpha-automl .You can also build an image to use with JupyterHub as follows:docker build -t alpha-automl:latest-jupyterhub --target alpha-automl-jupyterhub .See also the documentation on how to setup Alpha-AutoML + JupyterHub onKubernetes.
Package: alphabet
alphabetuses various methods to recognize text.InstallationThe easiest way to install the package is viapip:$ pip install alphabetUsageObfuscationfromalphabetimportalphabetkey="foobar"s=alphabet.alphabet("python")print(s)>pythont=s.obfuscate(key)print(bytes(t,'utf-8'))>b'\x16\x16\x1b\n\x0e\x1c'print(t.obfuscate(key))>pythonIdentify a stringfromalphabetimportalphabetalphabet('%!').identify()>'PostScript document text'alphabet('import os').identify()>'Python'alphabet('<div>foobar</div>').identify()>'XML'alphabet('Привет').identify()>'ru'
Package: alphabet2kana
alphabet2kanaConvert English alphabet to Katakanaアルファベットの日本語表記はUnidicと英語アルファベット - Wikipediaを参考にしています。特に、Zはゼット表記です。Installationpipinstallalphabet2kanaUsagefromalphabet2kanaimporta2ka2k("ABC")# "エービーシー"a2k("Alphabetと日本語")# "エーエルピーエイチエービーイーティーと日本語"a2k("Alphabetと日本語",delimiter="・")# "エー・エル・ピー・エイチ・エー・ビー・イー・ティーと日本語"a2k('k8s',delimiter='・',numeral=True)# "ケー・エイト・エス"半角にのみ対応しています。
全角アルファベットはmojimojiやjaconvなどで半角に変換してください。Only supported with half-width characters.