Saravanan666/pypi-org huggingface dataset:
Package: cashifypythonetcd
cashify-python-etcdCashify Python Repo to get Key values from ETCD.Pre-requisite:python-etcd library (https://pypi.org/project/python-etcd/)How to use:Use steps under if want to use directly from source codeInstall library using pip install git+https://git@github.com/saket-cashify/cashify-python-etcd.gitImport cashifypythonetcd and init class with parameters "host, protocol, port, app_name"Use function "get_property_value" with parameters "key, default" with class instance to get value from ETCDIf key is not defined in ETCD, we will get the default value backadd this line to requirements file to install "-e git+https://git@github.com/saket-cashify/cashify-python-etcd.git#egg=cashifypythonetcd" automaticallyUse these steps to use from PyPipip install cashifypythonetcdImport cashifypythonetcd and init class with parameters "host, protocol, port, app_name"Use function "get_property_value" with parameters "key, default" with class instance to get value from ETCDIf key is not defined in ETCD, we will get the default value backadd cashifypythonetcd==0.0.1 to requirements
Package: cashmere
Caching function calls.Free software: BSD 2-Clause LicenseInstallationpip install cashmereDocumentationhttps://python-cashmere.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 (2019-01-26)First release on PyPI.
Package: cashstatistic
cashstatisticUtility functions related to the Cash statisticThe Poisson distribution isP(x|mu) = exp(-mu) mu^x / x!TheCash statisticis defined to be the model (mu) dependent part of -2ln(P), analogous to the role that chi^2 plays for the Gaussian distribution,C = 2( mu - x*ln(mu) ).A modified version,C_m = 2( mu - x + x*ln(x/mu) ),is equivalent to C for parameter inference (i.e. has the same dependence on mu), and also has the nice property of becoming equivalent to chi^2 when x is large.Kaastra (2017)was kind enough to provide approximate expressions for the mean and variance of C_m, which can be used to determine whether the actual C_m corresponding to a fitted model is indicative of a good fit (just as chi^2 does for the Gaussian distribution).This package contains python code to calculate C, C_m, and the theoretical mean and variance of C_m. TheGitHub repocontains implementations in other languages.
Package: casimac
This Python project provides a supervised multi-class classification algorithm with a focus on calibration, which allows the prediction of class labels and their probabilities including gradients with respect to features. The classifier is designed along the principles of anscikit-learnestimator.The details of the algorithm have been published inPLOS ONE(preprint:arXiv:2103.02926).Complete documentation of the code is available viahttps://casimac.readthedocs.io/en/latest/. Example notebooks can be found in theexamplesdirectory.InstallationInstall the package via pip or clone this repository. In order to use pip, type:$pipinstallcasimacGetting StartedUse theCASIMAClassifierclass to create a classifier object. This object provides afitmethod for training and apredictmethod for the estimation of class labels. Furthermore, thepredict_probamethod can be used to predict class label probabilities.Below is a short example.fromcasimacimportCASIMAClassifierimportnumpyasnpfromsklearn.gaussian_processimportGaussianProcessRegressorimportmatplotlib.pyplotasplt# Create toy dataN=10seed=42X=np.random.RandomState(seed).uniform(-10,10,N).reshape(-1,1)y=np.zeros(X.size)y[X[:,0]>0]=1# Classifyclf=CASIMAClassifier(GaussianProcessRegressor)clf.fit(X,y)# PredictX_sample=np.linspace(-10,10,100).reshape(-1,1)y_sample=clf.predict(X_sample)p_sample=clf.predict_proba(X_sample)# Plot resultplt.figure(figsize=(8,3))plt.plot(X_sample,y_sample,label="class prediction")plt.plot(X_sample,p_sample[:,1],label="class probability prediction")plt.scatter(X,y,c='r',label="train data")plt.xlabel("X")plt.ylabel("label / probability")plt.legend()plt.show()📖CitationIf you find this code useful, please consider citing:@article{10.1371/journal.pone.0279876,
      doi={10.1371/journal.pone.0279876},
      author={Heese, Raoul and Schmid, Jochen and Walczak, Micha{\l} and Bortz, Michael},
      journal={PLOS ONE},
      publisher={Public Library of Science},
      title={Calibrated simplex-mapping classification},
      year={2023},
      month={01},
      volume={18},
      url={https://doi.org/10.1371/journal.pone.0279876},
      pages={1-26},
      number={1}
      }LicenseThis project is licensed under the MIT License - see the LICENSE file for details.
Package: casiopeia
Casadi Interface for Optimum experimental design and Parameter Estimation and Identification Applicationscasiopeia holds a user-friendly environment for optimum experimental design and parameter estimation and identification applications. It does so by providing Python classes that can be initialized with the problem specifications, while the computations can then easily be performed using the available class functions.Please note:casiopeia makes use of the optimization frameworkCasADi. For casiopeia to work, you need CasADi version = 3.1.0 to be installed on your system, otherwise the installation of casiopeia will abort or not might work as expected. Also, casiopeia is available only for Python 2.7.For an installation guide, a tutorial on how to use casiopeia and a detailed documentation, please visitthe manual pages.
Package: casioplot
Modulecasioplotfrom Casio calculator for Computer.This can help to develop python programs in your computer and run it before put it in your calculator.InstallationpipinstallcasioplotThis module use python 3.10.0.Need the modulePillowto work.Install Pillow:pipinstallpillowUsage exampleDraw a single pixelfromcasioplotimport*red=(255,0,0)set_pixel(10,10,red)show_screen()# Don't forget to show the screen to see the result.For more examples and usage, please refer to theDocs.Development setupNothing needed.Release History1.3.1Minor fix1.3.0Update settings and usageAdding documentation1.2.0ADD: Character support1.0.9FIX: images in the docs1.0.5FIX: import in the__init__file1.0.1First release on PyPI (this release is no more available now)1.0.0Work in progressMetaUniwix -odevlo.me@gmail.comDistributed under the MIT license. SeeLICENSEfor more information.https://github.com/uniwixContributingFork it (https://github.com/uniwix/casioplot/fork)Create your feature branch (git checkout-bfeature/fooBar)Commit your changes (git commit-am'Add some fooBar')Push to the branch (git push origin feature/fooBar)Create a new Pull RequestCompatibility NotesSome behaviors aren’t respected:The output isn’t show in the screen but saved on a picture.The functiondraw_stringcan’t print all the characters and doesn’t support the sizessmallandlarge.Only one calculator implemented:casio graph 90+e.v 1.3.2 - Uniwix
Package: casjobs
This basically does the same thing aspython-casjobsbut it only
depends onRequestswhich makes it more useful
in my opinion.UsageInstall it:pip install casjobsHere’s how you might get the fields in Stripe 82 that hit the Pisces
overdensity:import casjobs

query = """SELECT *
INTO mydb.pisces2
FROM Stripe82..Field AS p
WHERE p.mjd_g > 0 AND p.ramin < 355 AND p.ramax > 355
"""

jobs = CasJobs()
job_id = jobs.submit(query)
status = jobs.monitor(job_id)
print statusLicenseMIT
Package: cask
Caskis Injector-enabled, Python application microframework modelled after Flask.It’s purpose is to make the amount of boilerplate you need to write when developing your application smaller. Here’s a simple example:>>>fromcaskimportCask>>>frominjectorimportinject>>>>>>defconfigure(binder):...binder.bind(str,to='ABC')...>>>@Cask.run_main(modules=[configure])...@inject(s=str)...defmain(s):...print(s)...ABCCask.run_main(it works both as class and instance method, see below) does theif __name__ == '__main__'check for you. So this>>>app=Cask()>>>@app.run_main...defmain():...print(111)...111is shorter version of>>>app=Cask()>>>@app.main...defmain():...print(222)...>>>if__name__=='__main__':...app.run()...222ConstructionCaskconstructor andCask.run_mainclass method accept the following optional keyword arguments:modules- iterable of Injector modules, defaults to empty sequenceinjector- instance of Injector to configure and use, by default new instance will be created for youHooksCaskinstance provides the following decorators allowing you to register hooks (note that you can inject into registered functions):Cask.before_main- should expect no parameters, if non-None value is returned application execution main function won’t be executedCask.after_main- should expect singleresultparameter and return processed result (modified or not)Cask.exception_handler(ExceptionCLass)- will handle exception raised during the application execution, should expect single argument calledeand containing exception value:>>>app=Cask()>>>@app.exception_handler(Exception)...defhandle(e):...print('got exception%s'%(e,))...>>>@app.run_main...defmain():...raiseException(123)...gotexception123Cask.main- main function should expect no arguments and may return somethingYou can, of course, register more than one callable for hooks other thanmain.NoteOnly first matchingexception_handlerhook will be called, if any.ExecutionThis is what happens when you run Cask-based application:Injector is configured using providedmodulesbefore_mainhooks are calledIfbefore_mainhooks didn’t return value different than None,mainhook is executedafter_mainhooks are calledCopyrightCopyright (C) 2013 Jakub StasiakThis source code is licensed under MIT license, see LICENSE file for details.
Package: casl
NAMEcasl - simple implementation of CASL II assembler/COMET II simulator written in PythonWHAT IS CASL?caslis simple implementation of CASL II assembler and COMET II simulator
written in Python.  The CASL II assembler and the COMET II simulator are
designed for users to study principle operations of computers.  In particular,
CASL II and COMET II are used in the qualifying examination called ``Japan
Information-Technology Engineers Examination'' so that these programs should
be valuable for people who would like to acquire this qualification.Since both the CASL II assembler and the COMET II simulator are written only
in Python, these programs should work on almost all operating systems
including UNIX flavors, Windows, and macOS.caslincludes the following programs:casl- a simple implementation of CASL II assemblercomet- a simple implementation of COMET II simulatorAVAILABILITYThe latest version ofcaslis available athttps://pypi.org/project/casl/.COPYRIGHTCopyright (C) 2021 Hiroyuki Ohsaki (ohsaki[atmark]lsnl.jp)INSTALLATIONsudopip3installcaslFEEDBACKIf you find any bugs, first check if a newer version exists.  If not, please
send bug report or fixing patch to me viahttps://github.com/h-ohsaki/casl.
I appreciate your comments and/or suggestions.AUTHORHiroyuki Ohsaki <ohsaki[atmark]lsnl.jp>
Package: casl-django
CASL Django is an app that converts the usual Django permissions to CASL-Style rules.CASL is an isomorphic authorization JavaScript library:https://github.com/stalniy/casl/ExampleHaving a rule calledmy_app.change_item, will generate a CASL rule:{
    subject: 'my_app/item',
    action: 'change'
}If you have more than one rule for the same subject, for example:my_app.change_item
my_app.add_item
my_app.remove_itemThis will generate:{
    subject: 'my_app/item',
    actions: ['add', 'change', 'remove']
}ConfigurationBy default, the length for subject and action fields is 128 characters, you can
increase the length of them by adding to your settings file:CASL_DJANGO = {
    'subject-length': 256,
    'action-length': 256
}Custom PermissionsSometimes you’d like to have custom permissions for your users, given this, you
can add to your user using the Permission’sadd_permissionclass method:from casl_django.casl.permissions import Permissions

...

my_custom_permission = Permissions.create(subject="navigation", action="index")

...

Permissions.set_user_permission(user=user, permission=my_custom_permission)Or you can importcasl_django.models.UserPermissionand create objects as desired.Quick startAdd “casl_django” to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'casl_django',
]Runpython manage.py migrateto create the models.APIBy default, your user object should contain a related relationship calledcasl_permissions.
You can filter bypermission__subjectandpermission__actionand finally get the rules with
the queryset methodbundle().bundle()This method it’s included in the QuerySet’s forUserPermissions(user.casl_permissions) and forCASLPermission(CASLPermission.objects).This method returns a list like the following:[
    // These are regular django permissions transformed to CASL-Style rules
    {'subject': 'products/item', actions: ['add', 'change']},
    // These are CASLPermissions objects
    {'subject': 'navigation', actions: ['index', 'products']}
]The bundle consists in grouping same-subject rules and the actions, having less data
to send over the wire.
Package: casm-python
The CASM Python packagesThecasm-pythonPython packages provide a Python interface to the CASM libraries, implement wrappers to fitting methods and DFT software, and provide other tools for plotting and analysis.This version ofcasm-pythonis compatible withCASM>=1.2.A basic online reference is locatedhereFor a summary of changes, seeCHANGELOG.md.
Package: caso
casocASO is an OpenStack Accounting extractor.Free software: Apache licenseSource:https://github.com/IFCA/casoBugs:https://github.com/IFCA/caso/issuesDocumentation (the source is indoc/source/) is online atcaso documentation.AcknowledgementThis work is co-funded by theEOSC-hub project(Horizon 2020) under Grant number 777536.
Package: casparser_isin
CASParser-ISINISIN Database forcasparser.Installationpipinstall-Ucasparser-isinUsagefromcasparser_isinimportMFISINDbwithMFISINDb()asdb:scheme_data=db.isin_lookup("Axis Long Term Equity Fund - Growth",# scheme name"KFINTECH",# RTA"128TSDGG",# Scheme RTA code)print(scheme_data)SchemeData(name="axis long term equity fund - direct growth",
           isin="INF846K01EW2",
           amfi_code="120503",
           score=100.0)The database also contains NAV values on 31-Jan-2018 for all funds, which can be used for
taxable LTCG computation for units purchased before the same date.from casparser_isin import MFISINDb
with MFISINDb() as db:
    nav = db.nav_lookup("INF846K01EW2")
print(nav)Decimal('44.8938')Notescasparser-isin is shipped with a local database which may get obsolete over time. The local
database can be updated via the cli toolcasparser-isin--updatecasparser-isin will try to use the file provided byCASPARSER_ISIN_DBenvironment variable; if present, and the file exists
Package: caspercm
PurposeAllow JupyterLab user to save content to Oracle Object Storage.3 Steps to ConfigStep 1: Install this package# You may want to install it in the virtualenv you created for your JupyterLab
pip install caspercmStep 2: Config your jupyterlab# Edit your jupyterlab config file
# e.g. vi ~/.jupyter/jupyter_notebook_config.py
# add following

from caspercm import JupyterCasperCM
c.NotebookApp.contents_manager_class = JupyterCasperCM
c.NotebookApp.JupyterCasperCM.fstab = '/root/.oci/fstab.json'The example above shows your fstab.json is located at/root/.oci/fstab.json, it can be placed other places as well.Step 3: Config your fstab.jsonHere is an example of fstab.json{
    "/": {
        "namespace": "bmcdw",
        "bucket": "beta_jupyterlab_notebook",
        "prefix": "stonezhong/",
        "api_config": "/root/.oci/config"
    },
    "/public": {
        "namespace": "bmcdw",
        "bucket": "beta_jupyterlab_notebook",
        "prefix": "public/",
        "api_config": "/root/.oci/config"
    }
}Your notebooks root directory (aka/) is atstonezhong/of bucketbeta_jupyterlab_notebookin oci namespacebmcdwYour notebooks directory/publicis atpublic/of bucketbeta_jupyterlab_notebookin oci namespacebmcdwFor each mount point, told system your oci config is at/root/.oci/configHere is how/root/.oci/configlooks like: (the content is just an example, secret part has been altered)[DEFAULT]
key_file=/root/.oci/oci_api_key.pem
region=us-phoenix-1
tenancy=ocid1.tenancy.oc1..xyz
user=ocid1.user.oc1..xyz
fingerprint=00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00Note, it points to key file/root/.oci/oci_api_key.pemwhich shuold exist.
Package: cas-pip
CAS pipCommunity Attestation Pip integrationFree software: Apache Software License 2.0Documentation:https://cas-pip.readthedocs.io.FeaturesNotarizing requirements.txtAuthorizing requirements.txtNotarizing filesAuthorizing filesNotarizing hashesAuthorizing hashesAPI clientAsync API clientEasy integration with your softwareInstall itInstallation is very easy:pip install cas_pipUsageHistory0.1.0 (2022-04-29)First release on PyPI.
Package: caspo
[![Conda package](https://anaconda.org/bioasp/caspo/badges/version.svg)](https://anaconda.org/bioasp/caspo)
[![Documentation Status](https://readthedocs.org/projects/caspo/badge/?version=latest)](http://caspo.readthedocs.io/en/latest/?badge=latest)
[![license](https://img.shields.io/badge/license-GPLv3+-brightgreen.svg)](https://www.gnu.org/licenses/gpl.html)
[![Gitter](https://badges.gitter.im/bioasp/community.svg)](https://gitter.im/bioasp/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)### Reasoning on the response of logical signaling networksThe manual identification of logic rules underlying a biological system is
often hard, error-prone and time consuming.
Further, it has been shown that, if the inherent experimental noise is considered, many different logical networks
can be compatible with a set of experimental observations.
Thus, automatedinference of logical networks from experimental datawould allow for
identifying admissible large-scale logic models saving a lot of efforts and without any a priori bias.
Next, once a family a logical networks has been identified, one can suggest ordesign new experimentsin order to reduce the uncertainty provided by this family.
Finally, one canlook for intervention strategiesthat force a set of target species or compounds into a desired steady state.
Altogether, this constitutes a pipeline for automated reasoning on logical signaling networks.
Hence, the aim ofcaspois to implement such a pipeline providing a powerful and easy-to-use software tool for systems biologists.### DocumentationDetailed documentation about how to install and usecaspois available athttp://caspo.readthedocs.io.### SamplesSample files are included withcaspoand available for [download](http://bioasp.github.io/caspo/data.zip)### Citationcaspo: a toolbox for automated reasoning on the response of logical signaling networks families. (2017). Bioinformatics. [DOI](https://doi.org/10.1093/bioinformatics/btw738)### Related publications
*  Designing experiments to discriminate families of logic models. (2015). Frontiers in Bioengineering and Biotechnology 3:131. [DOI](http://dx.doi.org/10.3389/fbioe.2015.00131)Learning Boolean logic models of signaling networks with ASP. (2015). Theoretical Computer Science. [DOI](http://dx.doi.org/10.1016/j.tcs.2014.06.022)Reasoning on the Response of Logical Signaling Networks with ASP. (2014). John Wiley & Sons, Inc. [DOI](http://dx.doi.org/10.1002/9781119005223.ch2)Minimal intervention strategies in logical signaling networks with ASP. (2013). Theory and Practice of Logic Programming. [DOI](http://dx.doi.org/10.1017/S1471068413000422)Exhaustively characterizing feasible logic models of a signaling network using Answer Set Programming. (2013). Bioinformatics. [DOI](http://dx.doi.org/10.1093/bioinformatics/btt393)Revisiting the Training of Logic Models of Protein Signaling Networks with a Formal Approach based on Answer Set Programming. (2012) The 10th Conference on Computational Methods in Systems Biology. [DOI](http://dx.doi.org/10.1007/978-3-642-33636-2_20)
Package: casprotpy
CasProtPYCasProtPYis a Python project for generate CAS protocol TGTs and STs.The CAS protocol is a powerful ticket-based protocol implemented by CAS systems.It key concepts is to use a TGT (Ticket Granting Ticket) to stores the user SSO session, and then require a new ST (Service Ticket) to grant access for each request.So,CasProtPYcreates a TGT, and using it, generates a new ST for each HTTP request.CompatibilityCasProtPYsupports Python 3.6 or later.InstallationCasProtPYis a package on PyPI, so you can install it using pip:pip3installcasprotpyUsagefromcasprotpyimportcasprotpy# Setup CasProtPY using your CAS server configuration.casprotpy_client=casprotpy({'username':'cas_user','password':'cas_password','service':'service.com.br','base':'https://cas.login.com.br/v1/tickets'})casprotpy_client.tgt_for()# Return a valid TGT for configured CAS base.casprotpy_client.st_for()# Return a valid ST for configured CAS service.In addition, you can use the HTTP request methods present in theCasProtPY- which already generates the TGT and STs automatically:base_url='https://service.com.br'casprotpy_client.get('{}/users/{}'.format(base_url,'test'))casprotpy_client.post('{}/users'.format(base_url),{"name":"test","token":2})casprotpy_client.put('{}/users'.format(base_url),{"name":"test","token":3})casprotpy_client.patch('{}/users'.format(base_url),{"token":3})casprotpy_client.delete('{}/users/{}'.format(base_url,'test'))By default,casprotpy_client.st_for()creates a new TGT and stores it for 8 hours - it keeps using that TGT until it expires.But you can generate and pass your own TGT, like bellow:casprotpy_client.st_for(casprotpy_client.tgt_for())Testingpython3-munittestdiscover-stests/-p'*_test.py'
Package: caspyr
Cinchingly awesome scripts of Pythonic rapture.Packagescudamake writing CUDA for numpy arrays as trivial as possibleio*.matv7.3 (MATLAB) readingmultiprocessingUnorderedQMapplotting1, 2, and 3D plottingutilsglob (file pattern search)HTML tabulation (for notebook display)line profiling context managerslogging context managersmemoisation context managersterm (CLI) io utilitiesCLI ScriptsduplicateA python file (which generates itself) to get you started on new scriptsfilePrints info about given filesnvsminVidia GPU clock and memory monitorpandoc_filterplot3d3D scatter plots from CSV filespusherSend notifications to Android phonesremvMove files based on regexshowslice3D volume slicerTable of contentsInstallationInstallationLatest pypi stable releasepipinstallcaspyrLatest development release on githubPull and install in the current directory:pipinstall-egit+https://github.com/casperdcl/caspyr.git@master#egg=caspyrTab completionOptionally, systems withbash-completioncan install tab completion
support. Thecaspyr_completion.bashfile needs to be copied to an appropriate folder.On Ubuntu, the procedure would be:$# Ensure completion works for `git` itself$sudoapt-getinstallbash-completion$# Install `caspyr` completions$sudocpcaspyr_completion.bash/etc/bash_completion.d/followed by a terminal restart.ChangelogThe list of all changes is available either onGithub’s Releasesor on crawlers such asallmychanges.com.LicenceOpen Source (OSI approved):Copyright (c) 2016-8 Casper da Costa-Luis.This Source Code Form is subject to the terms of the
Mozilla Public License, v. 2.0.
If a copy of the MPL was not distributed with this file, You can obtain one
athttps://mozilla.org/MPL/2.0/.AuthorsCasper da Costa-Luis (@casperdcl)