Saravanan666/pypi-org huggingface dataset:
Package: attacus
Attacus :snake: :butterfly:Flutter Python ExtensionFlutterFlutter EmbedderSDLDevelopmentRequiredHatchOptionalNinjaClonegitclonehttps://github.com/crungelab/attacuscdattacusTool Chaincxbuildpybind11Develophatchshell
procure
cxbuilddevelopBuildcxbuildFlutter Custom DevicesThis will enable and display the location of your .flutter_custom_devices.json fileflutter config --enable-custom-devices
flutter custom-devicesAdd this to your .flutter_custom_devices.json file{"id":"attacus","label":"Attacus","sdkNameAndVersion":"Attacus 0.1","platform":null,"enabled":true,"ping":["ping","-n","1","-w","500","localhost"],"pingSuccessRegex":"[<=]\\d+ms","postBuild":["python","-m","attacus.post_build"],"install":["python","-m","attacus.install"],"uninstall":["python","-m","attacus.uninstall"],"runDebug":["python","main.py"],"forwardPort":null,"forwardPortSuccessRegex":null,"screenshot":null}Examplesflutterbuildbundle
pythonmain.pyorflutterrun
Package: attacut
AttaCut: Fast and Reasonably Accurate Word Tokenizer for ThaiHow does AttaCut look like?TL;DR:3-Layer Dilated CNN on syllable and character features. It’s6x fasterthan DeepCut (SOTA) while its WL-f1 on BEST is91%, only 2% lower.Installation$ pip install attacutRemarks:Windows users need to installPyTorchbefore the command above.
Please consultPyTorch.orgfor more details.UsageCommand-Line Interface$ attacut-cli -h
AttaCut: Fast and Reasonably Accurate Word Tokenizer for Thai

Usage:
  attacut-cli <src> [--dest=<dest>] [--model=<model>]
  attacut-cli [-v | --version]
  attacut-cli [-h | --help]

Arguments:
  <src>             Path to input text file to be tokenized

Options:
  -h --help         Show this screen.
  --model=<model>   Model to be used [default: attacut-sc].
  --dest=<dest>     If not specified, it'll be <src>-tokenized-by-<model>.txt
  -v --version      Show versionHigh-Level APIfrom attacut import tokenize, Tokenizer

# tokenize `txt` using our best model `attacut-sc`
words = tokenize(txt)

# alternatively, an AttaCut tokenizer might be instantiated directly, allowing
# one to specify whether to use `attacut-sc` or `attacut-c`.
atta = Tokenizer(model="attacut-sc")
words = atta.tokenize(txt)Benchmark ResultsBelows are brief summaries. More details can be found onour benchmarking page.Tokenization QualitySpeedRetraining on Custom DatasetPlease refer toour retraining pageRelated ResourcesTokenization VisualizationThai Tokenizer DockersAcknowledgementsThis repository was initially done byPattarawat Chormai, while interning atDr. Attapol Thamrongrattanarit's NLP Lab, Chulalongkorn University, Bangkok, Thailand.
Many people have involed in this project. Complete list of names can be found onAcknowledgement.
Package: attainia-django-extensions
Attainia Django Extensions is a collection of helpful utilities to be used in Attainia Django/Rest Framework projectsWhat’s included?Abstractions for Nameko RPC and Event subscription/dispatchInclude Correlation ID on Nameko RPC and eventsDjango REST Framework JWT authentication and permissionsUtils for reading environment variables as dictionaries and listsAudit trail base modelLibraries used:[Django REST Framework](https://github.com/encode/django-rest-framework)[Django CID](https://github.com/snowball-one/cid)[Nameko](https://github.com/nameko/nameko)[Django Nameko](https://github.com/Attainia/django-nameko)## Updating PyPI for a New Release of this LibraryYou will need to install Twine to update libraries in PyPI.  Twine is a utility for interacting with PyPI.  It’s OK to install this globally on your machine.` pip3 install twine `Create a .pypirc configuration file in your` vi~/.pypirc`The contents of this file should be as follows.` [pypi] username = attainia password = <password found in lastpass> `Set the permissions on the .pypirc file.` chmod 600~/.pypirc`From the library’s project root directory upload the newest version of the library to PyPI.  Be sure theattainia_django_extensions/__version__.pyreflects the correct version to be uploaded.` python3 setup.py upload `
Package: attax
Attax is python library with implementations of some common adversarial attacks
using JAX. For now this is a prototype at best and I refer you my other project,Foolbox, that also supports JAX and
provides a well-tested suite of adversarial attacks.InstallationpipinstallattaxExampleimportattaxfromfunctoolsimportpartialdefpredict(params,inputs):# see https://github.com/google/jax# ...params=...# model parametersx=...# input datay=...# labelsf=partial(predict,params)x_adv=attax.pgd(f,x,y,epsilon=0.3)print((f(x).argmax(axis=-1)==y).mean())print((f(x_adv).argmax(axis=-1)==y).mean())
Package: attd
Attribute Dictionaryattd is a Python package that provides a dictionary with attribute
access to keys. It is especially convenient when working with deeply
nested data from JSON APIs.Installation# Latest stable versionpipinstall-Uattd# Latest development versionpipinstall-Ugit+https://github.com/otsaloma/attdDocumentation>>>fromattdimportAttributeDict>>>data=AttributeDict({"a":{"b":{"c":1}}})>>>data["a"]["b"]["c"]1>>>data.a.b.c1>>>fromattdimportFallbackAttributeDict>>>data=FallbackAttributeDict()>>>data["a"]["b"]["c"]{}>>>data.a.b.c{}
Package: attendanceMarker
Compares excel files from webex and compares with roll call to mark
attendanceProject Featuresattendancemarkera starterClickcommand-line
applicationautomated unit tests you can run withpytestaSphinxdocumentation
projectGetting StartedThe project’s documentation contains a section to help youget
startedas a developer or user of the library.Development PrerequisitesIf you’re going to be working in the code (rather than just using the
library), you’ll want a few utilities.GNU MakePandocResourcesBelow are some handy resource links.Project DocumentationClickis a Python package for
creating beautiful command line interfaces in a composable way with
as little code as necessary.Sphinxis a tool that
makes it easy to create intelligent and beautiful documentation,
written by Geog Brandl and licnsed under the BSD license.pytesthelps you write
better programs.GNU Makeis a tool which
controls the generation of executables and other non-source files of
a program from the program’s source files.AuthorsDipayan Chattopadhyay-Initial work-githubSee also the list ofcontributorswho participated in this project.LicenseMIT LicenseCopyright (c) dipayan90Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
“Software”), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: attendance-tracker-email
Attendance TrackerTracks the attendance of participants in online events using their emailsInstallpipinstallattendance_tracker_emailPyPi PackageDirectory structureyour_project
│   README.md
│   your_script.py
│
└───email_files
   │   day1.txt
   │   day2.txt
   |   day3.txt------- day1.txtfirst2emai@outlook.com
second12email@gmail.comHow to usefrom attendance_tracker_email import attendedDirectory with emails as day1.txt, day2.txt etcdirectory = 'email_files'
print( attended.show_attended(directory))Next in the projectPublished for easy plug n play#739 Create a chrome extension for the frontendAuthentication to take attendance automaticallyTrack time attendedAdd more featuresIssuesa)Open an issueb)Star this for the futureLicenseMITContributions are welcome. Pull requests are welcome.
Package: attendant
General utilities for creating micro-servicesFree software: BSD licenseInstallationpip install attendantDocumentationhttps://attendant.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.1.0 (2016-07-29)First release on PyPI.
Package: attention
Keras Attention MechanismMany-to-one attention mechanism for Keras.InstallationPyPIpipinstallattentionExampleimportnumpyasnpfromtensorflow.kerasimportInputfromtensorflow.keras.layersimportDense,LSTMfromtensorflow.keras.modelsimportload_model,ModelfromattentionimportAttentiondefmain():# Dummy data. There is nothing to learn in this example.num_samples,time_steps,input_dim,output_dim=100,10,1,1data_x=np.random.uniform(size=(num_samples,time_steps,input_dim))data_y=np.random.uniform(size=(num_samples,output_dim))# Define/compile the model.model_input=Input(shape=(time_steps,input_dim))x=LSTM(64,return_sequences=True)(model_input)x=Attention(units=32)(x)x=Dense(1)(x)model=Model(model_input,x)model.compile(loss='mae',optimizer='adam')model.summary()# train.model.fit(data_x,data_y,epochs=10)# test save/reload model.pred1=model.predict(data_x)model.save('test_model.h5')model_h5=load_model('test_model.h5',custom_objects={'Attention':Attention})pred2=model_h5.predict(data_x)np.testing.assert_almost_equal(pred1,pred2)print('Success.')if__name__=='__main__':main()Other ExamplesBrowseexamples.Install the requirements before running the examples:pip install -r examples/examples-requirements.txt.IMDB DatasetIn this experiment, we demonstrate that using attention yields a higher accuracy on the IMDB dataset. We consider two
LSTM networks: one with this attention layer and the other one with a fully connected layer. Both have the same number
of parameters for a fair comparison (250K).Here are the results on 10 runs. For every run, we record the max accuracy on the test set for 10 epochs.MeasureNo Attention (250K params)Attention (250K params)MAX Accuracy88.2288.76AVG Accuracy87.0287.62STDDEV Accuracy0.180.14As expected, there is a boost in accuracy for the model with attention. It also reduces the variability between the runs, which is something nice to have.Adding two numbersLet's consider the task of adding two numbers that come right after some delimiters (0 in this case):x = [1, 2, 3, 0, 4, 5, 6, 0, 7, 8]. Result isy = 4 + 7 = 11.The attention is expected to be the highest after the delimiters. An overview of the training is shown below, where the
top represents the attention map and the bottom the ground truth. As the training  progresses, the model learns the
task and the attention map converges to the ground truth.Finding max of a sequenceWe consider many 1D sequences of the same length. The task is to find the maximum of each sequence.We give the full sequence processed by the RNN layer to the attention layer. We expect the attention layer to focus on the maximum of each sequence.After a few epochs, the attention layer converges perfectly to what we expected.Referenceshttps://www.cs.cmu.edu/~./hovy/papers/16HLT-hierarchical-attention-networks.pdfhttps://arxiv.org/abs/1508.04025https://arxiv.org/abs/1409.0473
Package: attention-sampling
This repository provides a python library to accelerate the training and
inference of neural networks on large data. This code is the reference
implementation of the methods described in our ICML 2019 publication“Processing Megapixel Images with Deep Attention-Sampling Models”.UsageYou can find examples of how to use our library in the providedscriptsor a very
concise one below.# Keras importsfromats.coreimportattention_samplingfromats.utils.layersimportSampleSoftmaxfromats.utils.regularizersimportmultinomial_entropy# Create our two inputs.# Note that x_low could also be an input if we have access to a precomputed# downsampled image.x_high=Input(shape=(H,W,C))x_low=AveragePooling2D(pool_size=(10,))(x_high)# Create our attention modelattention=Sequential([...Conv2D(1),SampleSoftmax(squeeze_channels=True)])# Create our feature extractor per patch, we assume that it returns a# vector per patch.feature=Sequential([...GlobalAveragePooling2D(),L2Normalize()])features,attention,patches=attention_sampling(attention,feature,patch_size=(32,32),n_patches=10,attention_regularizer=multinomial_entropy(0.01))([x_low,x_high])y=Dense(output_size,activation="softmax")(features)model=Model(inputs=x_high,outputs=y)Dependencies & InstallationTo install the library just runpip installattention-sampling. If you want
to extend our code clone the repository and install it in development mode.The dependencies ofattention-samplingareTensorFlowC++ tool chainCUDA (optional)DocumentationThere exists a dedicateddocumentation sitebut you are also encouraged to read thesource code
<https://github.com/idiap/attention-sampling>and thescriptsto get an
idea of how the library should be used and extended.ResearchIf you found this work influential or helpful in your research in any way, we
would appreciate if you cited us.@inproceedings{katharopoulos2019ats,
    title={Processing Megapixel Images with Deep Attention-Sampling Models},
    author={Katharopoulos, A. and Fleuret, F.},
    booktitle={Proceedings of the International Conference on Machine Learning (ICML)},
    year={2019}
}
Package: attentive
======================================.. image:: https://readthedocs.org/projects/attentive/badge/?version=latest:target: http://attentive.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https://github.com/sthysel/attentive/blob/master/docs/attentive.jpg?raw=true.. code:: pythonfrom attentive import StoppableThread, quitfrom random import randintclass Man(StoppableThread):def __init__(self, name):StoppableThread.__init__(self)self.name = namedef run(self):print('{} has quickened'.format(self.name))while not self.stopped:self.sleep(randint(1, 10))print('{} throws a {}'.format(self.name, randint(1, 6)))print('{} expires'.format(self.name))with Man('Trump'), Man('Wang'), Man('Erdoğan'):while not quit.is_set():quit.wait(1)Example Run***********.. code:: bash🚼Trump has quickened🚼Wang has quickened🚼Erdoğan has quickenedWang throws a ☣Trump throws a ☢Erdoğan throws a ☣Wang throws a ☣Wang throws a ☣Erdoğan throws a 🍭Erdoğan throws a ☣Trump throws a ☣^CErdoğan throws a 🍼☠  Erdoğan expiresWang throws a ☣☠  Wang expiresTrump throws a 🍼☠  Trump expiresUse ``attentive`` if you need to wire up a some worker threads that needs to cleanlyshut themselves down on a SIG_INT or SIG_TERM.``StoppableThread`` is a context managed thread that lives on while in context. Once it existscontext it sets its internal stopped flag that are periodically checked for state. This signalsthread state allowing the thread to cleanly exit.External state is controlled by a signal event, exiting the main context loop.Internally use the StoppableThread.sleep() method that is interrupted when stop()ed duringsleep.Install=======Install from pypi.. code::$ pip install attentiveInstall from source.. code::$ pip install .Versioning==========Current version is 0.1.5
Package: atternio
IntroductionAtternio is a PoC tool powered byflawfinderfor CWE prioritization according to MITRE CAPEC dictionary.The tool utilises open source CAPEC data provided in the form of JSON (STIX 2.x) files.AlgorithmThe tool receives a path to C/C++ sources as an input, which is passed to flawfinder to find CWEs.Each CWE is searched through CAPEC data to determine attack patterns (CAPEC-IDs) it can used in.When analyzing CAPEC data, the following metrics are taken into account:Severity (x_capec_severity);Likelihood (x_capec_likelihood_of_attack).An individual CWE can be found in multiple CAPEC-IDs.For each CWE in CAPEC-ID risk points are calculated using the following formula:cwe_risk = severity + likelihoodEach CAPEC-ID can contain multiple detected CWEs:capec_risk = sum(cwe_risk)Finally, the total number of risk points:total_risk = sum(capec_risk)When the risk enumeration is complete, the tool will output 2 tables:CWE Records- all CWEs detected with their location in provided sources;Prioritized CWE Records- prioritized CWEs with related CAPECs and percentage of shared risk.Usage$ python3 atternio/ --help
usage: [-h] --source PATH_INPUT [--install-dictionary] [-o OUTPUT] [--results]

Atternio - a PoC tool for CWE prioritization according to MITRE CAPEC dictionary.

optional arguments:
  -h, --help            show this help message and exit
  --source PATH_INPUT   path to file or directory
  --install-dictionary  if CAPEC dictionary is not present, install it
                        automatically
  -o OUTPUT, --output OUTPUT
                        path to output file
  --results             show only RESULTS section
Package: attgen
Table of ContentsDescriptionInstallationUsageLicenseDescriptionattgen is a tool to generate a french certificate during the COVID-19 confinment.
I give it not for the real usage you may have with it but for given the code I use
to play with pdfrw and reportlab libraries.Installationattgen is distributed onPyPIas a universal
wheel and is available on Linux/macOS and Windows and supports
Python 2.7/3.5+ and PyPy.$pipinstallattgenUsage$attgen--helpusage:attgen[-h][--verbose][--confCONF][--timeTIME][--outOUT]optionalarguments:-h,--helpshowthishelpmessageandexit--verbose,-vincreaseoutputverbosity--confCONF,-cCONFAddaconfigurationfile--timeTIME,-tTIMESetbegintime(eg.15h12)--outOUT,-oOUTSettheoutputfilenameThe configuration file is a yaml file:global_data:adresse:'1ruedelaplace,75000Paris'ville:"Paris"reasons:sport# reasons: "travail courses sante famille sport judiciaire missions"data:-lastname:'Jean'firstname:'Michel'birthday:'01/01/1970'town:"Amiens"-lastname:'Jean'firstname:'Marie'birthday:'01/01/1970'town:"Amiens"inputs:/tmp/certificate.pdfThis Config file can be also put in the Home directory under ${HOME}/.attgen
and will be read at the beginning of the execution.Examples of usage:attgenattgen-t15:00attgen-o/tmp/my_certificate.pdfattgen-cmy_config_file.yamlattgen-cmy_config_file.yaml-o/tmp/my_certificate.pdf-t15:00Licenseattgen is distributed under the terms ofApache License, Version 2.0
Package: attini-cdk-lib
Attini CDKThe Attini CDK library contains AWS CDK constructs for creating Attini deployment plans using the CDK.Attini allowed users to write deployment logic and package it together with the resources being deployed.
The deployments are performed from within the AWS account and uses only serverless resources.Together with the CDK the deployment logic can be we written in different programming languages.For more information about Attini. Please visitthe website. There
are several guides on how to get started with different tasks.Also check out thecdk examples repository, containing
some minimalistic example implementations.How to installnpm (Javascript/Typescript)Run the following command:npmi@attini/cdkMaven (Java)Add the following to your pom.xml file:<dependency><groupId>io.attini.cdk</groupId><artifactId>attini-cdk-lib</artifactId><version>1.2.1</version></dependency>PyPI(Python)Run the following command:pipinstallattini-cdk-libHow to useTo use Attini you need both the Attini CLI installed on your local machine and the Attini framework installed in
your AWS account. See theget started guidefor installation instructions.Start from the root of the folder/project containing the resources that should be deployed. First create a new folder
that will contain the CDK project that will become the deployment plan. In the folder, create a new cdk project
in the language you prefer.mkdirdeloyment-plan-projcddeloyment-plan-proj
cdkinit--languagetypescriptInstall the attini constructs in the new app.npmi@attini/cdkUpdate the deployment-plan-proj stack to extend "DeploymentPlanStack" instead of "Stack". This
will add the transformation necessary for Attini to function. This is also the stack where you create your deployment plan (find some exampleshere).
All Attini types are supported, for more information on the different types, please read theguidesordocumentation.In order to create an Attini distribution (the package that will be deployed) you need to create an
attini-config.yaml file containing some basic data, such as the distribution name and our package instructions.For this example, it could look like this:distributionName:typescript-cdk-demoinitDeployConfig:template:deployment-plan.yamlstackName:${environment}-${distributionName}-deployment-planpackage:prePackage:commands:-cd deployment-plan-proj-npm install-cdk synth > ../deployment-plan.yamlThe package commands will synthesise the template. For more information about packing, see thepackage a distribution guide.The distribution can then be packaged and the deployed. From the root of the project, execute:attinideployrun.For more information about deploying a distribution. See thedeploy a distribution guide.ResourcesAttini home pageGuides on getting startedDocumentationCdk examples repositoryAttini examples repository
Package: attlesnake
attlesnake: Attitude Dynamics in PythonA Python library for handling rigid body attitude dynamics (tailored for spacecraft).InstallationInstall with pip:pipinstallattlesnakeBasic Usage>>>importnumpyasnp>>>importattlesnakeasatt>>>ea321=att.EulerAngle321(np.pi/2,0,0)>>>print(ea321)1.5708,0.0000,0.0000>>>dcm=att.DCM.from_ea321(ea321)>>>print(dcm)0.0,1.0,-0.0-1.0,0.0,0.00.0,0.0,1.0
Package: atto
atto - Simple curses text editorInstallationpip install attoUsageAs script[user@localhost ~] atto "<filename>"In your codeimportattoatto.edit('filename.txt')Keysi to switch to insert modeESC to return from insert modeF4 to exit without savingF2 to saveF10 to save and exitArrow keys to move cursorLicenseatto is licensed underGPL LicenseRequirementscursor: Cross-platform library for showing and hiding cursorChangelog1.0.0Initial release1.1.0Major bug fixes,
Long lines handling improvements1.1.1Fixed tab bugs1.1.2Added --version command line switch1.1.3Minor bug fixes1.1.4Major bug fixes1.1.5Patched version1.1.6Added LICENSE file1.1.7Minor bug fixes1.1.8Added homepage1.1.9Patched version
Package: attotree
IntroductionRapid estimation of phylogenetic trees directly from FASTA files in the style ofMashtree. With the default options,
its output is identical to Mashtree,
but the computation takes only a fraction of time.InstallationUsing Biocondacondainstall-y-cbioconda-cconda-forgeattotreeUsing PyPIFirst, install the following dependencies:MashQuickTreeThen install the Attotree Python package:pipinstall-UattotreeQuick examplecondainstallattotreeattotreetests/*.faCommand-line parameters$ attotree -h

Program: attotree (rapid estimation of phylogenetic trees using sketching)
Version: 0.1.1
Author:  Karel Brinda <karel.brinda@inria.fr>

usage: attotree [-k INT] [-s INT] [-t INT] [-o FILE] [-f STR] [-L] genomes [genomes ...]

positional arguments:
  genomes     input genome file (fasta / gzipped fasta / list of files when "-L")

options:
  -h          show this help message and exit
  -v          show program's version number and exit
  -k INT      kmer size [21]
  -s INT      sketch size [10000]
  -t INT      number of threads [10]
  -o FILE     newick output [stdout]
  -f STR      tree inference algorithm (nj/upgma) [nj]
  -L          input files are list of filesIssuesPlease useGithub issues.ChangelogSeeReleases.LicenceMITAuthorsKarel Brinda<karel.brinda@inria.fr>