Saravanan666/pypi-org huggingface dataset:
Package: ancb
Another NumPy Circular BufferAnother NumPy Circular Buffer (or ANCB for short) is an attempt to make a circular buffer work with NumPy ufuncs for
real-time data processing. One can think of a NumpyCircularbuffer in ANCB as being a fixed length deque with random access
functionality (unlike the deque). For users more familar with NumPy, one can think of this buffer as a way of automatically
rolling the array into the right order.ANCB was developed by Drason "Emmy" Chow during their time as an undergraduate researcher at IU: Bloomington for use in
makingSavitzky-Golay filters, which take an array of positions in chronological or reverse-chronological order and produce
estimates of velocity, acceleration, and possibly higher order derivatives if desired.Looking for the documentation? You can find it here:https://ancb-docs.readthedocs.io/en/latest/
Package: ancestralcost
Ancestral CostAncestral Cost is a tool for validating multiple sequence alignments prior to performing ancestral sequence reconstruction.It checks for each position in a given ancestor that the presence of ancestral content implied to be there by a given alignment and tree is not substantially less parsimonious then the alternative of not having ancestral content there.InstallationUsing Pip$pipinstallancestralcostManual$gitclonehttps://github.com/gabefoley/ancestralcost$cdancestralcost$pythonsetup.pyinstallUsage$python-mancestralcost-a<alignment>-t<tree>WorkflowBefore performing ancestral sequence reconstruction (ASR) we can recognise that a multiple sequence alignment implies that every aligned column should have a common ancestor.Ancestral Cost checks that for every ancestral position that is implied by a given alignment and tree the parsimony cost of having ancestral content there isn't far greater than not having ancestral content.Ancestral Cost is intended to be run before ASR in order to validate alignments and trees. It highlights positions that may be erroneously aligned.If an alignment suggests two positions should be aligned but they are only present in distant clades then they shouldn't be one column but split into two columns. Failing to do this will influence ancestors that are predicted at these positions.First Ancestral Cost calculates all of the positions required to be there. In the example this is done by simply looking at the highest ancestral position implied by each column. From the example, N3 is the only ancestral node that has content at each of the four alignment positions, all of the other nodes have content at three alignment positions.It then calculates the parsimony cost for each implied position and reports on the cost of content being present and cost of content being absent.This allows users to filter on particularly informative sites or particularly large discrepencies in parsimony scores.The intention is to look at the positions identified by Ancestral Cost and potentially amend the multiple sequence alignment as a result.All commands-a Path to alignment
-t Path to phylogenetic tree
-n Node to return cost for (default is root)
-p Just return the positions required to be there
-f Return all ancestors as a FASTA file
-to Write out the ancestor tree
Package: anchcloud-sdk
This repository allows you to accessAnchCloudand control your resources from your applications.This SDK is licensed underApache Licence, Version 2.0.NoteRequires Python 2.7,
for more information please seeAnchCloud SDK DocumentationInstallationInstall viapip$ pip install anchcloud-sdkUpgrade to the latest version$ pip install --upgrade anchcloud-sdkGetting StartedIn order to operate AnchCloud IaaS.
you need applyaccess keyonanchcloud consolefirst.AnchCloud IaaS APIPass access key id and secret key into classAPIConnectionto create connection>>> from anchcloud.iaas.instances import *
>>> conn = APIConnection('CLIENTID','SECRETKEY')The variableAPIConnectionis the instance ofanchcloud.conn.iaas_client,
we can use it to call resource related methods.Example:# launch instances
>>> d = {
          "instance": {
              "zone": "ac2",
              "image_id": "centos64x64c",
              "instance_type": "PERFORMANCE",
              "cpu": 1,
              "memory": 1024,
              "count": 1,
              "login_mode": "passwd",
              "login_passwd": "Abcd1234"
          },
          "order": {
              "payment_type": "POSTPAY"
          }
      }
>>> ret = Instances(conn).create("ac2",d)

# stop instances
>>> d = {
        "instances": [
          "ins-Y4DFAOQ"
          ]
        }
>>> ret = Instances(conn).stop("ac2",d)

# describe instances
>>> d = {"status": "running,stopped"]}
>>> ret = Instances(conn).list("ac2",d)
Package: anchor-bio
![Anchor logo](https://raw.githubusercontent.com/YeoLab/anchor/master/logo/v1/logo.png)[![](https://img.shields.io/travis/YeoLab/anchor.svg)](https://travis-ci.org/YeoLab/anchor)[![](https://img.shields.io/pypi/v/anchor.svg)](https://pypi.python.org/pypi/anchor)[![codecov](https://codecov.io/gh/YeoLab/anchor/branch/master/graph/badge.svg)](https://codecov.io/gh/YeoLab/anchor)## What is `anchor`?Anchor is a python package to find unimodal, bimodal, and multimodal features in any data that is normalized between 0 and 1, for example alternative splicing or other percent-based units.* Free software: BSD license* Documentation: https://YeoLab.github.io/anchor## InstallationTo install `anchor`, we recommend using the[Anaconda Python Distribution](http://anaconda.org/) and creating anenvironment, so the `anchor` code and dependencies don't interfere withanything else. Here is the command to create an environment:```conda create -n anchor-env pandas scipy numpy matplotlib seaborn```### Stable (recommended)To install this code from the Python Package Index, you'll need to specify ``anchor-bio`` (``anchor`` was already taken - boo).```pip install anchor-bio```### Bleeding-edge (for the brave)If you want the latest and greatest version, clone this github repository and use `pip` to install```git clone git@github.com:YeoLab/anchorcd anchorpip install .  # The "." means "install *this*, the folder where I am now"```## Usage`anchor` was structured like `scikit-learn`, where if you want the "finalanswer" of your estimator, you use `fit_transform()`, but if you want to see theintermediates, you use `fit()`.If you want the modality assignments for your data, first make sure that youhave a `pandas.DataFrame`, here it is called `data`, in the format (samples,features). This uses a log2 Bayes Factor cutoff of 5, and the default Betadistribution parameterizations (shown [here]())```pythonimport anchorbm = anchor.BayesianModalities()modalities = bm.fit_transform(data)```If you want to see all the intermediate Bayes factors, then you can do:```pythonimport anchorbm = anchor.BayesianModalities()bayes_factors = bm.fit(data)```## History### 1.1.1 (2017-06-29)- In `infotheory.binify`, round the decimal numbers before they are written as strings### 1.0.1 (2017-06-28)- Documentation and build fixes### 1.0.0 (2017-06-28)* Updated to Python 3.5, 3.6### 0.1.0 (2015-07-08)* First release on PyPI.
Package: anchorconnector
Anchor ConnectorThis is a simple library for connecting to the unofficial Anchor API.It can be used to export data from your dashboard athttps://anchor.fm/dashboard.Supported Endpointstotal_playsplays_by_age_rangeplays_by_appplays_by_deviceplays_by_episodeplays_by_genderplays_by_geoplays_by_geo_cityepisodesFor each episode, the following endpoints are supported:episode_playsepisode_performanceepisode_aggregated_performanceepisode_all_time_video_dataSee__main.py__for all endpoints.CredentialsBefore you can use the library, you must extract your Anchor credentials from the dashboard;
they arenotexposed through your Anchor settings.You can use ourweb-extensionfor that
ortake a look at the codeto see how to do it manually.Installationpip install anchorconnectorUsage as a libraryfromanchorconnectorimportAnchorConnectorconnector=AnchorConnector(base_url=BASE_URL,webstation_id=WEBSTATION_ID,anchorpw_s=ANCHOR_PW_S,)end=datetime.now()start=end-timedelta(days=30)total_plays=connector.total_plays(True)logger.info("Podcast Total Plays ={}",json.dumps(total_plays,indent=4))plays_by_age_range=connector.plays_by_age_range(start,end)logger.info("Plays by Age Range ={}",json.dumps(plays_by_age_range,indent=4),)# plays_by_app = connector.plays_by_app(start, end)# plays_by_device = connector.plays_by_device(start, end)# plays_by_episode = connector.plays_by_episode(start, end)# plays_by_gender = connector.plays_by_gender(start, end)# plays_by_geo = connector.plays_by_geo()# plays_by_geo_city = connector.plays_by_geo_city("Germany")# ...forepisodeinconnector.episodes():logger.info("Episode ={}",json.dumps(episode,indent=4))web_episode_id=episode["webEpisodeId"]episode_meta=connector.episode_plays(web_episode_id)logger.info("Episode Metadata ={}",json.dumps(episode_meta,indent=4))# ...See__main.py__for all endpoints.DevelopmentWe usePipenvfor virtualenv and dev dependency management. With Pipenv
installed:Install your locally checked out code indevelopment mode, including its
dependencies, and all dev dependencies into a virtual environment:pipenvsync--devCreate an environment file and fill in the required values:cp.env.sample.envRun the script in the virtual environment, which willautomatically load
your.env:pipenvrunanchorconnectorTo add a new dependency for use during the development of this library:pipenvinstall--dev$packageTo add a new dependency necessary for the correct operation of this library, add
the package to theinstall_requiressection of./setup.py, then:pipenvinstallTo publish the package:pythonsetup.pysdistbdist_wheel
twineuploaddist/*ormakepublish
Package: anchorecli
OverviewThe Anchore CLI provides a command line interface on top of theAnchore EngineREST API.Using the Anchore CLI users can manage and inspect images, policies, subscriptions and registries for the following:Supported Operating SystemsAlpineAmazon Linux 2CentOSDebianGoogle DistrolessOracle LinuxRed Hat Enterprise LinuxRed Hat Universal Base Image (UBI)UbuntuSupported PackagesGEMJava Archive (jar, war, ear)NPMPython (PIP)Installing Anchore CLI from sourceThe Anchore CLI can be installed from source using the Python pip utilitygit clone https://github.com/anchore/anchore-cli
cd anchore-cli
pip install --user --upgrade .Or can be installed from the installed form source from the PythonPyPIpackage repository.Installing Anchore CLI on CentOS and Red Hat Enterprise Linuxyum install epel-release
yum install python-pip
pip install anchorecliInstalling Anchore CLI on Debian and Ubuntuapt-get update
apt-get install python-pip
pip install anchorecli
Note make sure ~/.local/bin is part of your PATH or just export it directly: export PATH="$HOME/.local/bin/:$PATH"Installing Anchore CLI on Mac OS / OS XUse Python’spippackage manager:sudo easy_install pip
pip install --user anchorecli
export PATH=${PATH}:${HOME}/Library/Python/2.7/binTo ensureanchore-cliis readily available in subsequent terminal sessions, remember to add that last line to your shell profile (.bash_profileor equivalent).To updateanchore-clilater:pip install --user --upgrade anchorecliConfiguring the Anchore CLIBy default the Anchore CLI will try to connect to the Anchore Engine athttp://localhost/v1with no authentication.
The username, password and URL for the server can be passed to the Anchore CLI as command line arguments.--u   TEXT   Username     eg. admin
--p   TEXT   Password     eg. foobar
--url TEXT   Service URL  eg. http://localhost:8228/v1Rather than passing these parameters for every call to the cli they can be stores as environment variables.ANCHORE_CLI_URL=http://myserver.example.com:8228/v1
ANCHORE_CLI_USER=admin
ANCHORE_CLI_PASS=foobarCommand line examplesAdd an image to the Anchore Engineanchore-cli image add docker.io/library/debian:latestWait for an image to transition toanalyzedanchore-cli image wait docker.io/library/debian:latestList images analyzed by the Anchore Engineanchore-cli image listGet summary information for a specified imageanchore-cli image get docker.io/library/debian:latestPerform a vulnerability scan on an imageanchore-cli image vuln docker.io/library/debian:latest osPerform a policy evaluation on an imageanchore-cli evaluate check docker.io/library/debian:latest --detailList operating system packages present in an imageanchore-cli image content docker.io/library/debian:latest osSubscribe to receive webhook notifications when new CVEs are added to an updateanchore-cli subscription activate vuln_update docker.io/library/debian:latestMore InformationFor further details on use of the Anchore CLI with the Anchore Engine please refer toAnchore Engine
Package: anchorer
AnchorerPlugin forvirtualenvwrapperthat extendsmkvirtualenvbehaviour to
add code that is loaded by the python interpreter for every run. The loaded code resolves symlinks in discovered
site-package directories, allowing symlinks to virtualenvs to be updated while scripts/services are running.Example problem anchorer solves# assuming you have the virtualenvwrapper python package installed, and have sourced virtualenvwrapper.shmkvirtualenvenv-v1
mkvirtualenvenv-v2# create a pseudo-virtualenv which is a symlink to a particular versionln-s"$WORKON_HOME/env-v1""$WORKON_HOME/active-env"# now use the linked environment to start something in env-v1workonactive-env# start some imaginary python service which may import modules a long time after startingpython-mmy_long_runner&# update the active symlink, switching what versionln-sT"$WORKON_HOME/env-v2""$WORKON_HOME/active-env"# imagine at this point that my_long_runner tries to import a module, it will be using un-resolved paths which will mean# the modules will be loaded from an environment that is not the one it started inArchitecturevirtualenvwrapper.anchorer.fix.main()resolves paths that are used at runtimecurrent working directorypaths used for determining where packages are foundvirtualenvwrapperrunsvirtualenvwrapper.anchorer.plugin.pre_mkvirtualenv(...)during calls tomkvirtualenvto
modify the virtualenv's site-packages directory:__anchorer.pyis added, it is a copy of the fix module__anchorer.pthis added, it simply imports__anchorerwhich causes the main method to run. Seesite docsfor more information on the mechanism
Package: anchore-syft
Syft Python DistributionsA project that packages Syft as a Python package, enablingsyftto be installed from PyPI:pipinstallanchore_syftAfterwards, Syft can be run using eithersyftoranchore_syft.PyPI package versions will follow themajor.minor.patchversion numbers of Syft releases.Binary wheels for Windows, macOS, and Linux for most CPU architectures supported on PyPI are provided.Syft PyPI Package HomepageSyft Source CodeSyft License: Apache-2.0Installing SyftSyft can be installed by pip with:pipinstallanchore_syftor:python-mpipinstallanchore_syftBuilding from the source dist package requires internet access in order to download one of the pre-compiled release binaries fromhttps://github.com/anchore/syft/releases.
Platforms that Syft doesn't provide pre-compiled binaries for will not work at all, unless someone feels inclined to submit a PR that fetches an appropriate Go compiler
to build Syft from source.Using with pipxUsingpipx run anchore_syft <args>will run Syft without any install step, as long as the machine has pipx installed (which includes GitHub Actions runners).Using with pyproject.tomlSyft can be added to theproject.dependencieskey in a pyproject.toml file for Python packages that require Syft.[project]dependencies=["anchore_syft"]LicenseThe code for this project is covered by theApache License, Version 2.0. Source distributions do not include a copy of the Syft source code or binaries. Binary wheels include a compiled Syft binary, which also falls under the Apache 2.0 license.Syft is distributed under theApache License, Version 2.0. For more information about Syft, visithttps://github.com/anchore/syft
Package: anchorman
# Welcome to AnchormanTurn your text into [hypertext](http://en.wikipedia.org/wiki/Hypertext)
and enrich the content. Anchorman finds terms in text and replaces
them with another representation.The replacement is rule-based. Each term is checked against the rules
and will be applied if valid.# How many items will be marked at all in the text.
replaces_at_all: 5# Input term has to be exact match in text.
case_sensitive: true## Featuresreplacement rulesconsider text units in the rules (e.g. paragraphs)replace only n items of the same itemspecify restricted_areas for linking by tag: a, imgsort elements by value before apply themreturn applied elements## Usage>>> from anchorman import annotate
>>> text = 'The quick brown fox jumps over the lazy dog.'
>>> elements = [{'fox': {'value': '/wiki/fox', 'data-type': 'animal'}}]
>>> print annotate(text, elements)
'The quick brown <a href="/wiki/fox" data-type="animal">fox</a> jumps over the lazy dog.'## InstallationTo install Anchorman, simply:pip install anchorman## Credits and contributionsWe published this at github and pypi to provide our solution to you.
Pleased for feedback and contributions.Thanks [@tarnacious](https://github.com/tarnacious) for inspiration
and first steps.## Todocheck if position exist in input and save extra processinghtml.parser vs lxml in bs4 - benchmarks and drawbacks<img src=”https://raw.githubusercontent.com/rebeling/anchorman/master/docs/anchorman.png” width=”200”>Stay tuned.
Package: anchor-pki
AnchorPython client for Anchor PKI. Seehttps://anchor.dev/for detailsConfigurationThe Following environment variables are available to configure the defaultAutoCert::Manager.HTTPS_PORT- the TCP numerical port to bind SSL to.ACME_ALLOW_IDENTIFIERS- A comma separated list of hostnames for provisioning certsACME_DIRECTORY_URL- the ACME provider's directoryACME_KID- your External Account Binding (EAB) KID for authenticating with the ACME directory above with anACME_HMAC_KEY- your EAB HMAC_KEY for authenticating with the ACME directory aboveACME_RENEW_BEFORE_SECONDS-optionalStart a renewal this number number of seconds before the cert expires. This defaults to 30 days (2592000 seconds)ACME_RENEW_BEFORE_FRACTION-optionalStart the renewal when this fraction of a certificate's valid window is left. This defaults to 0.5, which means when the cert is in the last 50% of its lifespan a renewal is attempted.AUTO_CERT_CHECK_EVERY-optionalthe number of seconds to wait between checking if the certificate has expired. This defaults to 1 hour (3600 seconds)If bothACME_RENEW_BEFORE_SECONDSandACME_RENEW_BEFORE_FRACTIONare set,
the one that causes the renewal to take place earlier is used.Example:Cert start (not_before) moment is :2023-05-24 20:53:11 UTCCert expiration (not_after) moment is :2023-06-21 20:53:10 UTCACME_RENEW_BEFORE_SECONDSis1209600(14 days)ACME_RENEW_BEFORE_FRACTIONis0.25- which equates to a before seconds value of604799(~7 days)The possible moments to start renewing are:14 days before expiration moment -2023-06-07 20:53:10 UTCwhen 25% of the valid time is left -2023-06-14 20:53:11 UTCCurrently theAutoCert::Managerwill use whichever is earlier.Example configurationHTTPS_PORT=44300ACME_ALLOW_IDENTIFIERS=my.lcl.host,*.my.lcl.hostACME_DIRECTORY_URL=https://acme-v02.api.letsencrypt.org/directoryACME_KID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXACME_HMAC_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXNotesThe HTTP User Agent for the anchor-autocert client isanchor-pki autocert python client v{VERSION}DevelopmentDevelopment and distribution is facilitated with poetry.lint the project - 2 steps:poetry run black ./poetry run pylint ./src/anchor_pkirun testspoetry run pytest tests/run tests with coveragepoetry run pytest --cov-report=term-missing --cov=./src/anchor_pki/ tests/buildpoetry buildDevelopment assumes a.envfile at the root of the python module.
Currently the only required items in it are:ACME_KID=...
ACME_HMAC_KEY=...
VCR_RECORD_MODE=none # set to have new tests record new cassetsTo re-record all cassettesMake sure theACME_KIDandACME_HMAC_KEYvalues in thetests/anchor_pki/autocert/test_manager.pyis kept in sync with the values in the.envfile when re-recording the
cassettes as the values will need to be available during CI to match the
cassette data.Update the.envfile with:VCR_RECORD_MODE=allThen update the value forvcr_recorded_atintests/anchor_pki/autocert/test_manager.pyto be sometime after the cassettes were recorded but before the certificates expire.LicenseThe python packages is available as open source under the terms of theMIT
License
Package: anchorpoint
A Python library for anchoring annotations with text substring selectors.Anchorpoint supplies TextQuoteSelector and TextPositionSelector
classes based on the Web Annotation Data Model, which is
aW3C Recommendation. Anchorpoint includes helper methods
for switching between selector types, and
apydanticschema for serialization. Anchorpoint is used
byLegislicefor referencing laws such as statutes, and
byAuthoritySpokefor referencing judicial opinions.API Documentationis available on readthedocs.Anchorpoint relies onpython-rangesto perform set operations on spans of text.Related PackagesIn Javascript, try theText Quote AnchorandText Position Anchorpackages.In Python trypython-ranges, which is the basis for much of the TextPositionSelector class’s behavior.
Package: anchorpy
AnchorPyAnchorPy is the gateway to interacting withAnchorprograms in Python.
It provides:A static client generatorA dynamic client similar toanchor-tsA Pytest pluginA CLI with various utilities for Anchor Python development.Read theDocumentation.Installation (requires Python >=3.9)pipinstallanchorpy[cli,pytest]Or, if you're not using the CLI or Pytest plugin features of AnchorPy you can just runpip install anchorpy.Development SetupIf you want to contribute to AnchorPy, follow these steps to get set up:InstallpoetryInstall dev dependencies:poetryinstallActivate the poetry shell:poetryshell
Package: anchorpy-fork
AnchorPyAnchorPy is the gateway to interacting withAnchorprograms in Python.
It provides:A static client generatorA dynamic client similar toanchor-tsA Pytest pluginA CLI with various utilities for Anchor Python development.Read theDocumentation.Installation (requires Python >=3.9)pipinstallanchorpy[cli]Or, if you're not using the CLI features of AnchorPy you can just runpip install anchorpy.Development SetupIf you want to contribute to AnchorPy, follow these steps to get set up:InstallpoetryInstall dev dependencies:poetryinstallInstallnox-poetry(note: do not use Poetry to install this, seehere)Activate the poetry shell:poetryshell
Package: anchors
anchorsPython package for calculating scores from ancnchor or modifier screensFree software: MIT licenseDocumentation:https://anchors.readthedocs.io.TutorialTo install:$ pip install anchorsBasic Usageimportpandasaspdfromanchorsimportget_guide_residuals,get_gene_residualslfc_df=pd.read_csv('https://raw.githubusercontent.com/PeterDeWeirdt/anchor_screen_parp_lfcs/master/parp_example_lfcs.csv')refernce_condition_df=pd.read_csv('https://raw.githubusercontent.com/PeterDeWeirdt/anchor_screen_parp_lfcs/master/parp_example_mapping.csv')guide_residuals,model_info,model_fit_plots=get_guide_residuals(lfc_df,refernce_condition_df)guide_mapping_df=pd.read_csv('https://raw.githubusercontent.com/PeterDeWeirdt/anchor_screen_parp_lfcs/master/brunello_guide_map.csv')gene_residuals=get_gene_residuals(guide_residuals,guide_mapping_df)FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-09-21)First release on PyPI.0.3.0 (2020-09-21)Calculate guide and gene residuals.