Saravanan666/pypi-org huggingface dataset:
Package: cdmpy
cdmpyPython script packaging offio-cdm, a python script to generateCrystalDiskMark-style test result withfio. Should work across multi platforms.Requirementfiopython3FeatureProvide some options of CrystalDiskMark, e.g., number of test runs, test file size, mixed r/w tests, zero buffers, etcShow IOPS and latency results for random read/write tests.
This actually combines the "default", "peak performance" and "real world performance" tests in CrystalDiskMarkEasy to add/customize new tests in command-line argumentsParsefioresult in json format to achieve more stabilityInstallationInstall via Pythonpip install .UsageCall script viacdmafter pip installation from anywhere.usage: cdm [target] [-h] [-0] [-a job] [-E] [-f jobfile] [-n number] [-s size] [-x [mix]]

positional arguments:
  target      The path of the directory to test. Default to current directory.

optional arguments:
  -h, --help  show this help message and exit
  -0          Initialize buffers with zeros. Default to use random buffers.
  -a job      Manually add multiple jobs. Format is "seq|rnd,<queue depth>,<thread number>".
              This overrides the preset jobs. This option can be used more than once.
  -E          Disable extra information (iops, latency) for random IO tests. Default is enabled.
  -f jobfile  Save jobfile and quit without running fio. Use "-" to print to stdout.
  -n number   Number of tests, default is 5.
  -s size     The size of file I/O. It is directly passed to fio. Default is 1G.
  -x [mix]    Add mixed rw test. Default is disabled. <mix> is read percentage. Default is 70.

Note:
Recommend to put the <target> argument as the first one since some of the optional arguments will consume it.Sample outputThe default tests are same asCrystalDiskMarktests: 5, size: 1G, target: . 173.3GiB/405.1GiB
|Name        | Read(MB/s)|Write(MB/s)|  Mix(MB/s)|
|------------|-----------|-----------|-----------|
|SEQ1M Q8 T1 |    2997.60|    2056.19|    1438.19|
|SEQ1M Q1 T1 |    1986.94|    1461.67|     941.04|
|RND4K Q32T16|    1816.04|     456.98|     434.18|
|... IOPS    |  443350.17|  111546.75|  105987.62|
|... latency |    1153.89|    4587.90|    2800.43|
|RND4K Q1 T1 |      54.20|     164.86|      34.43|
|... IOPS    |   13232.15|   40248.87|    8405.20|
|... latency |      74.76|      23.04|      67.78|ExamplesSet test file size to 512MB, 5 test runs with read, write and mix tests:cdm -s 512m -n 5 -xManually add jobs to replace the default ones:cdm -a seq,1,1 -a seq,32,1 -a rnd,16,8Show the equivalent fio command directly (without running the test):cdm -f - | fio --showcmd -Similar projectsShell version:https://github.com/buty4649/fio-cdm
Package: cdmpylintplugin
cdm-pylint-pluginThe project is aCodimension Python IDEpylint plugin.With this plugin the functionality of running pylint for a saved file is
available in the IDE.InstallationThe plugin is pip installable:pipinstallcdmpylintpluginThere is a little value (if any) to install it without theCodimension
IDE.When installed with Codimension python IDE the following ways are
available to invoke the pylint analysis:Ctrl+L when the current buffer is a python fileThe current buffer context menuThe main menuTools->PylintThe buffer toolbar buttonAlso, a pylintrc configuration file can be generated of edited. The
options are available via a buffer context menu.
Package: cdmsysinfoplugin
cdm-sysinfo-pluginThe project is aCodimension Python IDEsystem info plugin.With this plugin a couple of the main window status bar widgets are
added: one for the CPU usage percentage and one for the memory usage
percentage.InstallationThe plugin is pip installable:pipinstallcdmsysinfopluginThere is a little value (if any) to install it without theCodimension
IDE.
Package: cdn_assets
This package help you to use CDN Assets instead of downloading js and css by your self.Quick startInstall this package:pip install cdn_assetsAdd “cdn-assets” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'cdn_assets',
]Using filter we provide like this:{% load cdn_assets %}

{% cdn bootcss %}
    {% asset bootstrap 3.3.5 css bootstrap.min css %}
    {% asset jquery 2.2.1 jquery.min js %}
{% endcdn %}


This will output ::
<script src="//cdn.bootcss.com/jquery/2.2.1/jquery.min.js"></script>
<link href="//cdn.bootcss.com/bootstrap/3.3.5/css/bootstrap.min.css" rel="stylesheet">

Explaination ::
{% cdn bootcss %}
    {% asset jquery 2.2.1 jquery.min js %}
{% endcdn %}
The last parameter for asset filter is js, It would generate <script>
If the last parameter is css, then it would be <link rel='stylesheet'>
'/'.join() jquery 2.2.1 jquery.min -> jquery/2.2.1/jquery.min
adding the js it becomes jquery/2.2.1/jquery.min.js
The host is bootcss, so the url would be //cdn.bootcss.com/jquery/2.2.1/jquery.min.jsCDN Host list:HOST_MAPPINGS = {
    'bootcss':      'cdn.bootcss.com',
    'baidu':        'libs.baidu.com',
    'sinaapp':      'lib.sinaapp.com',
    'aspnetcdn':    'jax.aspnetcdn.com',
    'google':       'ajax.googleapis.com',
    'upai':         'upcdn.b0.upaiyun.com',
    'cdnjs':        'cdnjs.cloudflare.com',
    'staticfile':   'cdn.staticfile.org',
    '360':          'libs.useso.com'
}
Package: cdncheck
cdncheck-pythonThis is a Python wrapper around ProjectDiscovery'scdncheck. It is useful for checking whether a given IP address belongs to a cloud provider, e.g. Google, Azure, etc.Tests are run on a weekly schedule.InstallationIf you run into problems with installation, please make sure golang is installed on your system.$pipinstallcdncheckUsage (CLI)$cdncheck1.2.3.41.2.3.4doesnotbelongtoaCDN

$cdncheck168.62.20.37168.62.20.37belongstoCDN"azure"Usage (Python)>>>fromcdncheckimportcdncheck# empty string == not belonging to a CDN>>>cdncheck('1.2.3.4')''>>>cdncheck('168.62.20.37')'azure'
Package: cdn-definitions
Data definitions for Red Hat's content delivery network.SourceDocumentationPyPIThis project assists with the maintenance of a dataset influencing certain behaviors
of Red Hat's CDN, such as aliases between paths.See theUser Guidefor more information
if you are interested in consuming this data.LicenseThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Package: cdn-fastly
A Python client library for Fastly (http://www.fastly.com).Example:import fastly# Connects to Fastly using API key.client = fastly.connect("your-api-key")# Need to fully authenticate to access all features.client.login("email@domain.com", "h4x0rp4ssw0rd")# Get your account details.current_customer = client.get_current_customer()# Get your user details.current_user =  client.get_current_user()# List all services.all_services = client.list_services()# Create a service.service = client.create_service(current_customer.id,"test-service",comment="A service for testing out the client.")# Create a new version of the service.service_version = client.create_service_version(service.id,comment="A new version of this service.")# Create a domain.domain = client.create_domain(service.id,service_version.number,"www.test.com",comment="A new domain.")# List domains associated with this version.print client.list_domains(service.id, service_version.number)# Delete the domain we just created.client.delete_domain(service.id, service_version.number, domain.name)
Package: cdn-fmri
Causal Dynamic Network Modelingcdn-fmri is a Python-based package implementing causal dynamic network analysis for Functional magnetic resonance imaging (fMRI). It aims to improve the dynamic causal modeling with the optimization based method. Our optimization-based method and algorithm compute efficiently the ODE parameters from fMRI data, instead of comparing potentially a huge number of candidate ODE models. For a detailed introduction of dynamic causal modeling, see(1).Getting StartedThis package supports both python 2.7 and python 3.6.The example provided in the repo has been tested in mac os and Linux environment.These instructions will get you a copy of the project up running on your local machine for development and testing purposes.This package is also published in pypi.  For a quick installation, trypip install cdn-fmriPrerequisitesWhat things you need to install the software and how to install themSee setup.py for details of packages requirements.Installing from GitHubDownload the packages by using git clonehttps://github.com/xuefeicao/cdn.gitpython setup.py installIf you experience problems related to installing the dependency Matplotlib on OSX, please seehttps://matplotlib.org/faq/osx_framework.htmlIntro to our packageAfter installing our package locally, try to import cdn in your python environment and learn about package's function.
Note: our package name in pypi is cdn-fmri.import cdn.cdn_analysis as cdn_analysis
help(cdn_analysis.cdn_multi_sub)ExamplesThe examples subfolder includes a basic analysis of CDN analysis.Built WithPython 2.7Compatibilitypython 2.7python 3.6AuthorsXuefei Cao-Maintainer- (https://github.com/xuefeicao)Xi Luo(http://bigcomplexdata.com/)Björn Sandstede(http://www.dam.brown.edu/people/sandsted/)LicenseThis project is licensed under the MIT License - see the LICENSE file for details
Package: cdnget
Utility to download files from public CDN:CDNJS    (https://cdnjs.com)jsDelivr (https://www.jsdelivr.com)UNPKG    (https://unpkg.com)Google   (https://ajax.googleapis.com)Example:$ cdnget                           # list public CDN names
$ cdnget cdnjs                     # list libraries
$ cdnget cdnjs jquery              # list versions
$ cdnget cdnjs jquery latest       # show latest version
$ cdnget cdnjs jquery 2.2.4        # list files
$ mkdir -p static/lib              # create a directory
$ cdnget cdnjs jquery 2.2.4 static/lib  # download files
$ find static/lib -type f
static/lib/jquery/2.2.4/jquery.min.js
static/lib/jquery/2.2.4/jquery.min.map
static/lib/jquery/2.2.4/jquery.js
Package: cdnmon
IntroductionThis project provides IP range data of multiple CDN vendors via a Python package namedcdnmon.Installationpip install -i https://pypi.org/simple/ cdnmonUsageList all supported CDNsfromcdnmonimportEndpointendpoint=Endpoint(access_token="")cdns=endpoint.list_cdns()Get a CDN by namefromcdnmonimportEndpointendpoint=Endpoint(access_token="")cdn=endpoint.get_cdn(name="cloudflare")print(cdn)Get the IP ranges of a specific CDNfromcdnmonimportEndpointendpoint=Endpoint(access_token="")cdn=endpoint.get_cdn(name="cloudflare")latest_ipv4_networks=cdn.ipv4_networks[-1]forlatest_ipv4_networkincdn.latest_ipv4_networks:print(latest_ipv4_network.networks)print(latest_ipv4_network.updated_at)print(latest_ipv4_network.source)FAQHow to obtain an access token?Please contactwangyihanger@gmail.com.
Package: cdn-test
cdn-testCLI tool created to automate tests for verify time cache in web-site delivered by CDN - CloudFront.How to InstallThecdn-testpackage is hosted in Python Package Index (PyPI). To
installcnd-test, it’s recommend create avirtualenvand install the package usingpip. Example:$virtualenv--python=$(whichpython3)venv$sourcevenv/bin/activate$pip3installcdn-testManual$cdn-test-husage:cli.py[-h][--urlURL][--time-step[TIME_STEP]][--http-verb[HTTP_VERB]][--header-name[HEADER_NAME]][--output-file[OUTPUT_FILE]][--version]options:-h,--helpshowthishelpmessageandexit--urlURL,-uURLURLtoverifiedcacheincloudfront--time-step[TIME_STEP],-s[TIME_STEP]timeintervalbetweenrequests--http-verb[HTTP_VERB],-x[HTTP_VERB]HTTPverbutilizedforrequeststoURL--header-name[HEADER_NAME]responseheadernamethatcontains"Miss from cloudfront"or"Hit from cloudfront"--output-file[OUTPUT_FILE],-f[OUTPUT_FILE]filepathtosaverecords--version,-vshowcdn-testversionExamplesEach 10 seconds, it will be made a request withGETHTTP verb to web-site hosted by cloudformation with follow URLhttps://aws.amazon.com/pt/cloudfront/. The request history will be save on~/cdn-report.json.$cdn-test--url=https://aws.amazon.com/pt/cloudfront/--http-verb=GET--time-step=10s--output-file=~/cdn-report.jsonPackage Struct├──src│├──cdn_test# source code directory│├──__init__.py# module definition file│├──cli.py# parser cli parameters│└──domain.py# module composed only domain logics├──poetry.lock# poetry dependencies versions├──pyproject.toml# poetry package definition file├──README.rst# project documentation└──tests# directory composed only with unit tests└──...
Package: cdo-api-client
[![PyPI version](https://badge.fury.io/py/cdo-api-client.svg)](https://badge.fury.io/py/cdo-api-client)# cdo-api-client
Python interface to cdo api. Built to allow quick and easy query for weather
data to pandas dataframe objects.## Installation
Notes:Super duper alpha at the moment` pip installcdo-api-client`or for python3` pip3 installcdo-api-client`Read more [here](https://www.ncdc.noaa.gov/cdo-web/webservices/v2#gettingStarted)Example usage [here](docs/example/dc_weather_data.py)
Package: cdochain
This module helps create chains of cdo commands for easy manipulation of
climate data.FeaturesMethod execution is lazy and gets processed only on function callChain.execute().Input supports Unix style pathname pattern search.The Input will be first run withgloband checked if
several files match.
:exclamation:If that is the case a temporary file will be created.Output can be a file on disc, annetCDF4.Datasetor (not) maskednumpy.ndarray.Installationpython3.5-mpipinstallcdochain--pre— or —gitclonehttps://github.com/OnionNinja/cdochain.gitcdcdochainpython3.5setup.pyinstallTL;DRfromcdochainimportchainingascchinput='./tests/testdata/sresa1b_ncar_ccsm3-example.nc'output='./enso34-mm.nc'data=cch.Chain(ifile=input,ofile=output)enso34=data.sellonlatbox(190,240,-5,5).monmean()out=enso34.execute()UsageThis module implementsmethod
chainingfor theClimate Data Operators(CDO)
tool from the Max Planck Institute for Meteorology. Let us start:fromcdochainimportchainingascchFor initialisation one has to defineinput,output, and may
define severaloptions.InputNow we have to define the files we want to work on:To use one fileinput='./tests/testdata/sresa1b_ncar_ccsm3-example.nc'To use several files you can give a Unix style patterninput='./tests/testdata/*.nc'This creates a temporary file:exclamation:OutputFor defining the output we have several options.To output afile on disc:data=cch.Chain(ifile=input,ofile='/path/to/output.nc')To output annetcdf4.Datasetobject:data=cch.Chain(ifile=input,ofile='netCDF4')To output annumpy.ndarrayobject:data=cch.Chain(ifile=input,ofile='array:<var>')# numpy.ndarray# ordata=cch.Chain(ifile=input,ofile='maarray:<var>')# masked numpy.ndarray<var>defines the variable to be extracted and saved to
numpy.ndarray.OptionsAs for options one can use the same as described on theCDO
website.
The default isoptions='-O-fnc'.OperationsThe operations defined inCDOcan now
be used on the data element.analysis=data.sellonlatbox(190,240,-5,5).sellevidx(1).mermean()fn=analysis.execute()Have fun :neckbeard:
Package: cdoctest
A C/C++ DecTestA C/C++ DecTest which run tests by using clang-repl interaction comments.
It works on Linux. (MacOS is not tested. Windows dll is not supported.)CAUTIONIt worked with clang-repl-kernel 0.1.7. It should be run properly.
And also libclang also should be installed and work properly.Using the CDocTestsample.cpp#include"sample.h"namespacetest{/**>>> test::Fac fac;>>> printf("%d\n",fac.fac(7));5040*/intFac::fac(intn){return(n>1)?n*fac(n-1):1;}/**>>> test::Fac fac;>>> printf("%d\n",fac.fac2(5));120*/intFac::fac2(intn){return(n>1)?n*fac(n-1):1;}}sample.h#pragma once/**>>> test::Fac fac;>>> printf("%d\n",fac.fac(5));120>>> printf("%d\n",fac.fac2(5));120*/namespacetest{classFac{public:/**>>> test::Fac fac;>>> printf("%d\n",fac.fac(5));120*/intfac(intn);intfac2(intn);};}build library sample.soclang-c-osample.osample.cpp
clang-sharedsample.o-osample.sorun test with source code (cpp or h) with librarypython3-mcdoctest-cdtt=sample.h-cdtl=sample.so-cdtcip=/usr/lib/llvm-18/lib/clang/18/include/
Package: cdopt
Welcome to CDOptA Python toolbox for optimization on closed Riemannian manifolds with support for automatic differentiationRiemannian optimization is a powerful framework to tackle nonlinear optimization problems with structural equality constraints. By transforming these Riemannian optimization problems into the minimization of constraint dissolving functions, CDOpt allows for elegant and direct implementation various unconstrained optimization approaches for Riemannian optimization problems. CDOpt also provides user-friendly frameworks for training manifold constrained neural networks by PyTorch and Flax.The constraint dissolving approaches have the following advantages:Direct optimization & high efficiency:CDOpt is developed from theconstraint dissolving approaches, which transforms Riemannian optimization problems to unconstrained ones. Therefore, we can utilize various highly efficient solvers for unconstrained optimization, and directly apply them to solve Riemannian optimization problems. Benefited from the rich expertise gained over the decades for unconstrained optimization, CDOpt is very efficient and naturally avoids the difficulties in developing specialized solvers for Riemannian optimization.Plug-in neural layers:CDOpt provides various plug-in neural layers for PyTorch and \Pkg{Flax} packages. With only minor changes in the original codes, users can easily build and train the neural network while constrain the weights over various manifolds.High efficiency:CDOpt has high compatibility with various numerical backends, including NumPy, SciPy, PyTorch, JAX, Flax, etc . Users can directly apply the advanced features of these packages to accelerate optimization, including the automatic differentiation, GPU/TPU supports, distributed optimization frameworks, just-in-time (JIT) compilation, etc.Customized constraints:The manifold classes in CDOpt can be constructed only from the expressions of constraints. Users can easily and directly describe Riemannian optimization problems in CDOpt without any geometrical materials of the Riemannian manifold (e.g., retractions and their inverse, vector-transports, etc.).
Package: cdot
cdotcdot provides transcripts for the 2 most popular PythonHGVSlibraries.It works by:Converting RefSeq/Ensembl GTFs to JSONProviding loaders for the HGVS libraries, via JSON.gz files, or REST API viacdot_rest)We currently support ~905k transcripts (vs ~141k in UTA v.20210129)NewSeechangelog2023-07-05:BioCommons HGVS DataProvider fixesSupport for mouse transcripts (Mus Musculus GRCm38 and GRCm39)2023-04-03:#41 - Support for T2T CHM13v2.0example codeInstallpip install cdotExamplesBiocommons HGVSexample:import hgvs
from hgvs.assemblymapper import AssemblyMapper
from cdot.hgvs.dataproviders import JSONDataProvider, RESTDataProvider

hdp = RESTDataProvider()  # Uses API server at cdot.cc
# hdp = JSONDataProvider(["./cdot-0.2.14.refseq.grch37.json.gz"])  # Uses local JSON file

am = AssemblyMapper(hdp,
                    assembly_name='GRCh37',
                    alt_aln_method='splign', replace_reference=True)

hp = hgvs.parser.Parser()
var_c = hp.parse_hgvs_variant('NM_001637.3:c.1582G>A')
am.c_to_g(var_c)more Biocommons examples:PyHGVSexample:import pyhgvs
from pysam.libcfaidx import FastaFile
from cdot.pyhgvs.pyhgvs_transcript import JSONPyHGVSTranscriptFactory, RESTPyHGVSTranscriptFactory

genome = FastaFile("/data/annotation/fasta/GCF_000001405.25_GRCh37.p13_genomic.fna.gz")
factory = RESTPyHGVSTranscriptFactory()
# factory = JSONPyHGVSTranscriptFactory(["./cdot-0.2.14.refseq.grch37.json.gz"])  # Uses local JSON file
pyhgvs.parse_hgvs_name('NM_001637.3:c.1582G>A', genome, get_transcript=factory.get_transcript_grch37)more PyHGVS examples:Q. What's the performance like?UTA public DB: 1-1.5 seconds / transcriptcdot REST service: 10/secondcdot JSON.gz: 500-1k/secondQ. Where can I download the JSON.gz files?Download from GitHub releases- RefSeq (37/38) - 72M, Ensembl (37/38) 61MDetails on what the files containhereQ. How does this compare to Universal Transcript Archive?Both projects have similar goals of providing transcripts for loading HGVS, but they approach it from different waysUTA aligns sequences, then stores coordinates in an SQL database.cdot convert existing Ensembl/RefSeq GTFs into JSONSeewiki for more detailsQ. How do you store transcripts in JSON?Seewiki pagefor the format.We think a standard for JSON gene/transcript information would be a great thing, and am keen to collaborate to make it happen!Q. What does cdot stand for?cdot, pronounced "see dot" stands for Complete Dict of TranscriptsThis was developed for theAustralian GenomicsShariantproject, due to the need to load historical HGVS from lab archives.
Package: cdown
docstestspackageTools for code owners filesFree software: MIT licenseInstallationpip install cdownYou can also install the in-development version with:pip install https://github.com/andreoliwa/python-cdown/archive/master.zipDocumentationhttps://python-cdown.readthedocs.io/DevelopmentTo run all the tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append tox
Package: cdox
cdoxA script to automate documentation of your C APIs in markdown format.cdoxreads in a source code file creates documentation based on the comments. it's sort of like doxygen but simpler and creates a markdown file.Usagecdox infile outfileInstallationpip install cdoxRulescdox keywords:@name:name of documentation.@description:description of file documentation.@desc:a description of a function.@param:a bullet point for info on a function paramter.@return:a bullet point for what the function returns.rules:the keywords must be in multiline comments.the multiline comments must start with/* *and end with* */each on their own line.the function name/protoype must be on the line following the* */Example UsageCheck outexample.mdfor what the below example would produce.// test.c/* ** strncmp** @desc: compare two strings up to `n` characters.** @param: `s1` - a char array of at least one char.* @param: `s2` - a char array of at least one char.* @param: `n` - the number of chars to compare of each string.** @return: 0 if strings are the same else a non-zero int.* */intstrncmp(constchar*s1,constchar*s2,intn){while(n>0&&*s1==*s2++){if(*s1++=='\0')return0;n--;}return(n==0?0:*s1-*--s2);}todoadd feature to allow making section headersadd @global keyword for documentation of global variables
Package: cdpam
Contrastive learning-based Deep Perceptual Audio Metric (CDPAM)[Webpage]Contrastive Learning For Perceptual Audio SimilarityPranay Manocha,Zeyu Jin,Richard Zhang,Adam FinkelsteinThis is a Pytorch implementation of our new and improved audio perceptual metric. It contains (0) minimal code to run our perceptual metric (CDPAM).(0) Usage as a loss functionMinimal basic usage as a distance metricRunning the command below takes two audio files as input and gives the perceptual distance between the files. It should return (approx)distance = 0.1696. Some GPU's are non-deterministic, and so the distance could vary in the lsb.Installing the metric (CDPAM - perceptual audio similarity metric)pipinstallcdpamUsing the metric is as simple as:importcdpamloss_fn=cdpam.DPAM()wav_ref=cdpam.load_audio('sample_audio/ref.wav')wav_out=cdpam.load_audio('sample_audio/2.wav')dist=loss_fn.forward(wav_ref,wav_out)