Saravanan666/pypi-org huggingface dataset:
Package: amphi
amphiMoviePy OOP wrapperAdditional RequirementsImageMagick binary fileMatplotlibOpenCVUsagefromamphiimportAmphimovie=Amphi()movie.new_audio("music","<path/to/audio/file>")movie.new_video("video1","<path/to/audio/file>")movie.new_video("video2","<path/to/audio/file>")movie.new_video("video3","<path/to/audio/file>",stabilize=True)movie.new_text("title","My Video",font="Arial",fontsize=100,duration=4)print("Processing media resources...")movie.video("video1").subclip(0,5).keep("video1a")movie.video("video2").subclip(0,2).keep("video2a")movie.video("video3").subclip(2).keep("video3a")movie.video("video1a").composite("title").keep("intro")movie.concatenate_by_video_id(["intro","video2a","video3a"])movie.set_audio("music")movie.render()ifmovie.save("my-movie.mp4",fps=30,bitrate="16000k"):print("The video has been successfully saved.")
Package: ampho
Amphois a Python library that provides simple and convenient way to develop applications by splitting them into
small, easily maintainable parts.Build statusDocumentationSee thedocumentationfor details.ChangelogSee theCHANGELOG.rstfor details.SupportUse project’sissue tracker.ContributingSee theCONTRIBUTING.rstfor details.AuthorsAlexander Shepetko– initial work.LicenseThis project is licensed under the MIT License. See theLICENSE.rstfile for details.
Package: ampho-model
Abstract base data model for using in Ampho applications.Build statusInstallationpipinstall-Uampho-modelUsageUseampho_model.Modelas a base class for your models.ChangelogSee theCHANGELOG.rstfor details.SupportUse project’sissue tracker.ContributingSee theCONTRIBUTING.rstfor details.AuthorsAlexander Shepetko– initial work.LicenseThis project is licensed under the MIT License. See theLICENSE.rstfile for details.
Package: ampl
An IPython extension for working with AMPL.SeeAMPL magic: using IPython as an interface to AMPLfor an introduction to IAMPL.IAMPL is licensed under the terms of theBSD license.InstallationUsingpipThe following command installs the ampl extension usingpip:$ pip install amplUsingeasy_installThe following command installs the ampl extension usingeasy_install:$ easy_install amplCreditsThanks Leonardo Taccari (sbebo) for implementing
the realtime output.
Package: amplabs
AmpLabsAmpLabs is a open source platform which provides easy way of data visualisation.DescriptionBuilt on top of Plotly.js, Dash, Pandas and Flask, AmpLabs ties modern UI elements like dropdowns and graphs directly to analytical Python code.Method provided -MethodDescriptionParameterReturn valuereadCSVmethod to read a csv filefile_path = path of the file to readdataframereadDATmethod to read a dat filefile_path = path of the file to readdataframereadTDMSmethod to read a tdms filefile_path = path of the file to readdataframeminutesToSecondsmethod to convert time column from minutes to secondscolumn = column list that has to be convertedconverted column listshowHeadersmethod to display list of headersdf = dataframelist of headersconvertToExcelmethod which convert a dataframe to excel filedf = dataframe, file_path = path of the file where it should be saved-addHeadersmethod to add headers to the dataframedf = dataframe, column_list = list of columns that should be addeddataframeplotmethod to generate graph from the data framedata_list = list of dataframes, data_names = list of names of dataframescolors(optional) = list of colorsOther Services by AmpLabsWebsite to upload and plot data on cloud [www.app.amplabs.ai]Desktop Application to visual data locally
Package: amplecode.recipe.template
amplecode.recipe.template is a Buildout recipe for generating files using Jinja2 templates. The recipe configures a Jinja2 environment, by default relative to the Buildout directory, allowing templates to extend and include other templates relative to the environment.Downloads are available from pypi:http://pypi.python.org/pypi/amplecode.recipe.template/Buildout Optionstemplate-file (required): One or more Jinja2 template file paths.target-file (required): One of more target file paths. The number of files must match the number of template files.base-dir: Base directory of the Jinja2 environment. Template file paths are relative to this directory. Default is the Buildout directory.target-executable: One or more boolean flags (yes|no|true|false|1|0) indicating the executability of the target files. If only one flag is given it is applied to all target files.eggs: Reserved for a list of eggs, conveniently converted into a pkg_resources.WorkingSet when specifiedAdditional options are simply forwarded to the templates, and options from all the other parts listed in buildout:parts are made available throughparts.<part-name>.<option-name>andparts[<part-name>][<option-name>].Lists of ValuesIt is possible for a recipe option to contain one or more values, separated by whitespace. A split filter is available for when you want to iterate over the whitespace separated values in your Jinja2 template:#!/bin/sh
{% for cmd in cmds|split %}
   echo "{{ cmd }}"
{% endfor %}Minimal Examplefoo.txt is created from foo.txt.jinja2 without any extra options:[buildout]
parts = foo

[foo]
recipe = amplecode.recipe.template
template-file = foo.txt.jinja2
target-file = foo.txtLarger Examplefoo.txt is created from myapp/foo.txt.jinja2, bar.sh is created from myapp/bar.sh.jinja2, the second will be executable, and both templates can utilize the additional options specified:[buildout]
parts = foo

[foo]
recipe = amplecode.recipe.template
base-dir = myapp
template-file =
    foo.txt.jinja2
    bar.sh.jinja2
target-file =
    foo.txt
    bar.sh
target-executable =
    false
    true
project_name = Another Example
author = MeChangelogSee the CHANGELOG fileLicenseSee the LICENSE file
Package: amplia-client
This library contains classes that encapsulate the call to the Amplia
service (X.509 certificate issuing solution) for Amplia applicationsThe recommend way to installRest PKI Client Libis through [PyPi](https://pypi.org/):$ pip install amplia-clientOr informing on your project’srequirements.txtfile:amplia-client==1.0.0For more information, see [Amplia](http://www.lacunasoftware.com/en/certificate/#/amplia) page.
Package: amplicov
amplicon_coverage_plotThe script will generate aninteractive barplotgiven amplicon info inbed6/bedpeformat and coverage information in cov/bam file.DependenciesProgramming/Scripting languagesPython >=v3.7The pipeline has been tested in v3.7.6Python packagesnumpy >=1.15.1plotly >=4.7.1pysam >= 0.15.4Third party softwares/packagessamtools >=1.9- process bam fileInstallationInstall by pippip install amplicovInstall by condaconda install -c bioconda amplicon_coverage_plotInstall from sourceClone theamplicon_coverage_plotrepository.git clone https://github.com/chienchi/amplicon_coverage_plotThen change directory toamplicon_coverage_plotand install.cd amplicon_coverage_plot
python setup.py installIf the installation was succesful, you should be able to typeamplicov -hand get a help message on how to use the tool.amplicov -hUsageusage: amplicov [-h] (--bed [FILE] | --bedpe [FILE])
                (--bam [FILE] | --cov [FILE]) [-o [PATH]] [-p [STR]] [--pp]
                [--mincov [INT]] [--version]

Script to parse amplicon region coverage and generate barplot in html

optional arguments:
  -h, --help            show this help message and exit
  --pp                  process proper paired only reads from bam file
                        (illumina)
  --count_primer        count overlapped primer region to unqiue coverage
  --mincov [INT]        minimum coverage to count as ambiguous N site
                        [default:10]
  -r [STR], --refID [STR]
                        reference accession (bed file first field)
  --depth_lines DEPTH_LINES [DEPTH_LINES ...]
                        Add option to display lines at these depths (provide depths as a list of integers) [default:5 10 20 50]
  --gff [FILE]          gff file for data hover info annotation
  --version             show program's version number and exit

Amplicon Input (required, mutually exclusive):
  --bed [FILE]          amplicon bed file (bed6 format)
  --bedpe [FILE]        amplicon bedpe file

Coverage Input (required, mutually exclusive):
  --bam [FILE]          sorted bam file (ex: samtools sort input.bam -o
                        sorted.bam)
  --cov [FILE]          coverage file [position coverage]

Output:
  -o [PATH], --outdir [PATH]
                        output directory
  -p [STR], --prefix [STR]
                        output prefixTestcd tests
./runTest.shOutputs-- prefix_amplicon_coverage.txtIDWhole_AmpliconUniqueWhole_Amplicon_Ns(cov<10)Unique_Amplicon_Ns(cov<10)nCoV-2019_1217.7453.000.000.00nCoV-2019_21552.831235.500.000.00nCoV-2019_33164.222831.730.000.00nCoV-2019_42005.161658.000.000.00etc...Table Header Definition in the amplicon_coverage.txtWhole_Amplicon_Ns(cov<10): The number of aligned position with coverage < 10 or (--mincov) in the Whole Amplicon regionUnique_Amplicon_Ns(cov<10): The number of aligned position with coverage < 10 or (--mincov) in the Unique region-- prefix_amplicon_coverage.htmlcolor black for < 5x and blue for <20x
Package: amplify
About Fixstars AmplifyFixstars Amplify SDK is a middleware library for Ising machines developed by Fixstars Amplify Corporation. Ising machines specialize in solving optimization problems described by quadratic polynomials of binary variables. Various types of Ising machines implemented with digital circuits and GPUs have been released, starting with the quantum annealing machine by D-Wave Systems. This middleware is an intermediate layer between hardware and applications using Ising machines. We provide various functions that improve the convenience of the machines and enable highly efficient application software development.
Package: amplify-aws-utils
amplify_aws_utilsUtility functions for working with AWS resources though Boto3 with less hiccups.About AmplifyAmplify builds innovative and compelling digital educational products that empower teachers and students across the
country. We have a long history as the leading innovator in K-12 education - and have been described as the best tech
company in education and the best education company in tech. While others try to shrink the learning experience into the
technology, we use technology to expand what is possible in real classrooms with real students and teachers.Getting StartedPrerequisitesamplify_aws_utils requires the following to be installed:python >= 3.8InstallationThis package can be installed usingpippip install amplify_aws_utilsBuilding From SourceFor development,tox>=2.9.1is recommended.Python package can be built as follows:python setup.py sdistThis creates a package indistdirectory.Running Testsamplify_aws_utilsusestox. You will need to install tox withpip install tox.
Runningtoxwill automatically execute linters as well as the unit tests. You can also run them individually with
the -e argument.For example,tox -e lint,py38-unitwill run the linters, and then the unit tests in python 3.8To see all the available options, runtox -l.DeploymentDeployment is done with Travis.Package is built as described above, and is uploaded to PyPI repo usingdevpi-clientUsageFunctions provided by this package can be imported after package has been installed.Example:from amplify_aws_utils.resource_helper import throttled_call
Package: amplify-model
AmplifyGetting startedAmplifycan be installed viapip install amplify-model. Then, the model can be used in an existing project by callingfrom amplify.src.flex_calculation import FlexCalculator.Alternatively, the repo can of course be cloned. The source code ofAmplifylies underamplify/src/flex_calculation.py. Its results require thedata_classes.pyfile. The calculation relies only on basic python modules.TestsThe basic tests lie underamplify/tests/unit_tests. They can be started by callingpytest.test_total_flex_calculation.py: Assert valid flexibility calculationtest_ppr_detection.py: Validate problem detectiontest_accept_short_trades_scenarios.py: Verify valid sizing of multi purpose obligations with MPOs lasting single time intervalstest_accept_long_trades_scenarios.py: Verify valid sizing of multi purpose obligations with MPOs lasting more than one time interval (contains multiple scenarios)full_result_test_accept_long_trades_scenarios.txt: Contains result of full accept long trades test. For all failed tests, some information is given as well as a short summary.RequirementsUntil now,Amplifyonly requires thepytestmodule, which can be installed viapip.LicenseAmplify is licensed under the Apache 2.0 license.Project statusAmplifyis still under development.Author of documentationPaul Hendrik Tiemann (2022)
Package: amplify.qaoa
About Amplify QAOAAmplify QAOA is a submodule of Amplify, a middleware library for Ising machines developed by Fixstars.  Quantum Approximate Optimization Algorithm (QAOA) is algorithm for solving optimization problems (e.g. Ising model).
This module supports to solve optimization problems with QAOA for Ising model by the quantum computers or simulators of a quantum computer.
Package: amplikyzer2
amplikyzeris short for amplicon analyzer.
It is a software to analyze sequenced amplicons with emphasis on
flowgram analysis (resulting from 454 or IonTorrent sequencing) and methylation analysis after sodium bisulfite treatment.amplikyzer2is the successor toamplikyzerand adds support for the analysis of FASTQ reads from Illumina’s MiSeq sequencer.Please read the information in the [Wiki](https://bitbucket.org/svenrahmann/amplikyzer/wiki/Home).
Package: amplitf
AmpliTFLibrary of primitives for amplitude analyses in high-energy physics using TensorFlow v2IntroductionThe package includes the primitives to operate with relativistic kinematics (operations with Lorentz vectors, elements of helicity formalism), and descriptions of the dynamical functions (such as Breit-Wigner line shapes) using Google TensorFlow library.This package is a fork of TensorFlowAnalysishttps://gitlab.cern.ch/poluekt/TensorFlowAnalysisthat includes only the "stable" basic functionality.The package is compatible with TensorFlow v2.PrerequisitesTensorFlow v2.1NumPySymPyIMinuitROOT is not required anymore.LinksTensorFlowAnalysis:https://gitlab.cern.ch/poluekt/TensorFlowAnalysisZFit:https://github.com/zfit/zfitComPWA:https://github.com/ComPWA
Package: amplitude-analytics
Amplitude Python SDKThe official Amplitude backend Python SDK for server-side instrumentation.DevelopmentRun Server LocallyRefer toexamples/README.md.Run Unit Tests LocallyRun Directlypython3 -m unittest discover -s ./src -p 'test_*.py'Run withtoxpip3 install --user tox
python3 -m tox -e pyAmplitude and Ampli WrapperAmpli SDKis autogenerated library based on your pre-definedtracking plan. The Ampli Wrapper, is a lightweight wrapper over the Amplitude SDK that provides type-safety, supports linting, and enables features like input validation. The code replicates the spec in the Tracking Plan and enforces its rules and requirements. This repository is aboutAmplitude SDK. To learn more about Ampli Wrapper, please refer to theAmpli Pythonandexamples.Installation and Quick StartPlease visit theDeveloper Centerfor instructions on installing and using our the SDK.ChangelogView thereleases here.Need Help?If you have any issues using our SDK, feel free tocreate a GitHub issueor submit a request onAmplitude Help.
Package: amplitude-data-wrapper
Amplitude data wrapperThis is a wrapper forAmplitudeAPIs. You can use it to query and export data from your account and use the taxonomy API.Built withrequestsandtqdmWhy use this package instead of other wrappers?This package supports regions and so you can use it with Amplitude accounts in the EU and USA.This package also supports using a proxy so you can keep your project API keys and API secrets confidential.Supported Amplitude APIs and docsAmplitude data wrapperSupported Amplitude APIs and docsDashboard Rest APIPrivacy APICohort APIExport APITaxonomy APISee examples below and inexample.pyInstall withpip install amplitude-data-wrapperDashboard Rest APIResults from an existing chartGet data from EU account by settingregion=1.importamplitude_data_wrapper.analytics_apiasampr=amp.get_chart(chart_id,api_key,api_secret,region=1)r.status_code# 200r.text# print dataGet data from US account by settingregion=2.r=amp.get_chart(chart_id,api_key,api_secret,region=2)r.status_code# 200r.text# print dataGet data from EU account with a proxy by setting region and proxy using a dictionary.proxies={"http":"http://myproxy.domain.org/path"}r=amp.get_chart(chart_id,api_key,api_secret,region=1,proxy=proxies)r.status_code# 200r.text# print dataEvent segmentationlets you export events with segments and filters.our_event_dict={"event_type":"pageview","group_by":[{"type":"event","value":"app"},{"type":"event","value":"team"}],}data=amp.get_event_segmentation(api_key=api_key,secret=api_secret,start="20220601",end="20220602",event=our_event_dict,metrics="uniques",interval=1,limit=1000,)User searchlets you search for a user with a specific Amplitude ID, Device ID, User ID, or User ID prefix.user=amp.find_user(user=example_id_eu,api_key=api_key,secret=api_secret,region=1)Privacy APIDelete user data with adeletion jobdeleteme=amp.delete_user_data(user["matches"][0]["amplitude_id"],email=email,api_key=api_key,secret=api_secret,region=1,ignore_invalid_id=True,delete_from_org=False,)Get a list of deletion jobstobe_deleted=amp.get_deletion_jobs(start="2022-06-01",end="2022-07-01",api_key=api_key,secret=api_secret,region=1,)Cohort APIGetting one cohortproxies={"http":"http://myproxy.domain.org/path"}file_path="path-to/cohortdata.csv"kull=amp.get_cohort(api_key,api_secret,cohort_id,filename=file_path,props=1,region=1,proxy=proxies,)Export APIExport API - Export your project's event datastart="20220601T00"end="20220601T01"data=amp.export_project_data(start=start,end=end,api_key=api_key,secret=api_secret,filename="path-to/projectdata_eu.zip",region=1,)Taxonomy APIGet all event typestypes=amp.get_all_event_types(api_key=api_key,secret=api_secret,region=1)
Package: amplitude-experiment
Experiment Python SDKAmplitude Python Server SDK for Experiment.Installationpipinstallamplitude-experimentRemote Evaluation Quick Startfromamplitude_experimentimportExperiment,RemoteEvaluationConfig,RemoteEvaluationClient,User# (1) Get your deployment's API keyapiKey='YOUR-API-KEY'# (2) Initialize the experiment remote evaluationexperiment=Experiment.initialize_remote(api_key)# (3) Fetch variants for a useruser=User(device_id="abcdefg",user_id="user@company.com",user_properties={'premium':True})# (4) Lookup a flag's variant## To fetch synchronousvariants=experiment.fetch(user)variant=variants['YOUR-FLAG-KEY']ifvariant:ifvariant.value=='on':# Flag is onelse:# Flag is off# To fetch asynchronousexperiment.fetch_async(user,fetch_callback)deffetch_callback(user,variants):variant=variants['YOUR-FLAG-KEY']ifvariant:ifvariant.value=='on':# Flag is onelse:# Flag is offLocal Evaluation Quick Start# (1) Initialize the local evaluation client with a server deployment key.experiment=Experiment.initialize_local(api_key)# (2) Start the local evaluation client.experiment.start()# (3) Evaluate a user.user=User(device_id="abcdefg",user_id="user@company.com",user_properties={'premium':True})variants=experiment.evaluate(user)More InformationPlease visit our :100:Developer Centerfor more instructions on using our the SDK.See ourExperiment Python SDK Docsfor a list and description of all available SDK methods.Need Help?If you have any problems or issues over our SDK, feel free tocreate a github issueor submit a request onAmplitude Help.
Package: amplitude-logger
amplitude-loggerPython client for Amplitude API v2 (https://developers.amplitude.com/docs/http-api-v2)Installationpip install amplitude-loggerUsageAmplitude APIRequest your API key athttps://developers.amplitude.com/Use that token to initialize client:fromamplitudeimportAmplitudeLoggerapi_key='xxxxxxxxxxxxxxx'amplitude_logger=AmplitudeLogger(api_key=api_key)event_args={"user_id":"USER_ID","event_type":"Event Name","event_properties":{"param":"value","data":"value"},}event=amplitude_logger.create_event(**event_args)amplitude_logger.log_event(event)
Package: amplitude-python
[CircleCI]AMPLITUDE-PYTHONPython API for Amplitude Analytics Logging - https://amplitude.comThis API is a simple (unofficial) wrapper for the Amplitude HTTP API1. Install amplitude-pythonPotential preparation before installing: create and activate virtualenv or conda environment1.1 Install from pypi with conda or pippip install amplitude-python1.2 Install from github$ git clone https://github.com/atveit/amplitude-python.git$ cd amplitude-python$ python setup.py instal2. Logging to Amplitude with amplitude-pythonRecommend having a look at Amplitude HTTP API Documentation before start logging.import amplitude# initialize amplitude loggeramplitude_logger = amplitude.AmplitudeLogger(api_key = "SOME_API_KEY_STRING")# example eventevent_args = {"device_id":"somedeviceid", "event_type":"justtesting","event_properties":{"property1":"somevalue", "propertyN":"anothervalue"}event = amplitude_logger.create_event(**event_args)# send event to amplitudeamplitude_logger.log_event(event)3. Test amplitude-python modulepython setup.py test
Package: amplitude-python-sdk
amplitude-python-sdkUnofficialSDK for the Amplitude HTTP API, providing a user-friendly interface through Pydantic models.Seethe Amplitude docsfor more information on the various API methods and their parameters.WARNING: This library is in very early development, and APIs are not guaranteed to be stable. Please bear that in mind when using this library.Installationpip install amplitude-python-sdkDependenciespydanticis used to create cleaner and more readable data models within this library.requestsis used to handle all HTTP interactions with the Amplitude API.UsageMethods supportedCurrently, only theIdentify APIand theHTTP API V2are supported. Support for other API methods coming soon!Identify API Exampleimportloggingfromamplitude_python_sdk.common.exceptionsimportAmplitudeAPIExceptionfromamplitude_python_sdk.v1.clientimportAmplitudeV1APIClientfromamplitude_python_sdk.v1.models.identifyimportIdentification,UserPropertiesclient=AmplitudeV1APIClient(api_key='<YOUR API KEY HERE>')try:resp=client.identify([Identification(user_id='example',user_properties=UserProperties()])exceptAmplitudeAPIException:logging.exception('Failed to send identify request to Amplitude')Event API Client Exampleimportloggingfromamplitude_python_sdk.common.exceptionsimportAmplitudeAPIExceptionfromamplitude_python_sdk.v2.clients.event_clientimportEventAPIClientfromamplitude_python_sdk.v2.models.eventimportEventfromamplitude_python_sdk.v2.models.event.optionsimportEventAPIOptionsclient=EventAPIClient(api_key='<YOUR API KEY HERE>')try:events=[Event(user_id='example',event_type='Clicked on Foo',event_properties={'foo_id':'bar','click_position':5,})]client.upload(events=events,options=EventAPIOptions(min_id_length=1),)exceptAmplitudeAPIException:logging.exception('Failed to log event to Amplitude')Batch Event Upload API ExampleExactly the same as the Event V2 API example, just substituteclient.batch_uploadforclient.upload.
Package: amplitude-sdk
Amplitude Python SDKSDK for Amplitude APISDK for Amplitude API.https://developers.amplitude.com/docshttps://github.com/paulokuong/amplitudeRequirementsPython 3.7.0GoalTo provide a python API client for Amplitude API.(More clients to be implemented)Code sampleRequesting Behavioral Cohorts APIfromamplitude_sdkimportBehavioralCohortsClientb=BehavioralCohortsClient(api_key='xxxxxxx',secret='yyyyyyyy')b.list_cohorts()ContributorsPaulo Kuong (@paulokuong)