Saravanan666/pypi-org huggingface dataset:
Package: cardec
CarDECCarDEC (CountadaptedregularizedDeepEmbeddedClustering) is a joint deep learning computational tool that is useful for analyses of single-cell RNA-seq data. CarDEC can be used to:Correct for batch effect in the full gene expression space, allowing the investigator to remove batch effect from downstream analyses like psuedotime analysis and coexpression analysis. Batch correction is also possible in a low-dimensional embedding space.Denoise gene expression.Cluster cells.ReproducibilityWe described and introduced CarDEC in ourmethodological paper. To find code to reproduce the results we generated in that paper, please visit this separategithub repository, which provides all code (including that for other methods) necessary to reproduce our results.InstallationRecomended installation procedure is as follows.InstallAnacondaif you do not already have it.Create a conda environment, and then activate it as follows in terminal.$ conda create -n cardecenv
$ conda activate cardecenvInstall an appropriate version of python.$ conda install python==3.7Install nb_conda_kernels so that you can change python kernels in jupyter notebook.$ conda install nb_conda_kernelsFinally, install CarDEC.$ pip install CarDECNow, to use CarDEC, always make sure you activate the environment in terminal first ("conda activate cardecenv"). And then run jupyter notebook. When you create a notebook to run CarDEC, make sure the active kernel is switched to "cardecenv"UsageAtutorial jupyter notebook, together with a dataset, is publicly downloadable.Software RequirementsPython >= 3.7TensorFlow >= 2.0.1, <= 2.3.1scikit-learn == 0.22.2.post1scanpy == 1.5.1louvain == 0.6.1pandas == 1.0.1scipy == 1.4.1Trouble shootingInstallation on MacOS should be smooth. If installing on Windows Subsystem for Linux (WSL), the user must properly configure their g++ compiler to ensure that the louvain package can be built during installation. If the compiler is not properly configured, the user may encounter a following deprecation error similar to the following."DEPRECATION: Could not build wheels for louvain which do not use PEP 517. pip will fall back to legacy 'setup.py install' for these. pip 21.0 will remove support for this functionality. A possible replacement is to fix the wheel build issue reported above."To fix this error, try to install the libxml2-dev package.
Package: cardec-cite
CarDEC_CITECarDEC(CountadaptedregularizedDeepEmbeddedClustering) is a joint deep learning computational tool that is useful for analyses of single-cell RNA-seq data. CarDEC can be used to:Correct for batch effect in the full gene expression space, allowing the investigator to remove batch effect from downstream analyses like psuedotime analysis and coexpression analysis. Batch correction is also possible in a low-dimensional embedding space.Denoise gene expression.Cluster cells.I then developed CarDEC_CITE based on CarDEC to further analyze CITE-seq data with addtional protein expression compared to single-cell RNA-seq data.To use CarDEC_CITE, You will need to first read and QC your data to remove those bad cells. I used “pp.filter_cells“ and “pp.filter_genes” in the Scanpy package, and here is atutorialpublished for CarDEC usage.Please note this current version of CarDEC_CITE:Does not support model_counts() function, so no denoised counts will be generated. But you can get denoised z scores with make_inference() function.It only supports two cases: 1.LVG = LVP = True, 2.LVG = LVP = False.ReproducibilityJustin Lakkis described and introduced CarDEC in hismethodological paper. To find code to reproduce the results he generated in that paper, please visit this separategithub repository, which provides all code (including that for other methods) necessary to reproduce his results.InstallationRecomended installation procedure is as follows.InstallAnacondaif you do not already have it.Create a conda environment usingcardec_cite.yml, and then activate it as follows in terminal.$ conda env create -f cardec_cite.yml
$ conda activate cardec_citeNow, to use CarDEC_CITE, always make sure you activate the environment in terminal first ("conda activate cardec_cite"). And then run jupyter notebook. When you create a notebook to run CarDEC_CITE, make sure the active kernel is switched to "cardec_cite".Software RequirementsPython >= 3.7TensorFlow >= 2.0.1, <= 2.3.1scikit-learn == 0.22.2.post1scanpy == 1.5.1louvain == 0.6.1pandas == 1.0.1scipy == 1.4.1Trouble shootingInstallation on MacOS should be smooth. If installing on Windows Subsystem for Linux (WSL), the user must properly configure their g++ compiler to ensure that the louvain package can be built during installation. If the compiler is not properly configured, the user may encounter a following deprecation error similar to the following."DEPRECATION: Could not build wheels for louvain which do not use PEP 517. pip will fall back to legacy 'setup.py install' for these. pip 21.0 will remove support for this functionality. A possible replacement is to fix the wheel build issue reported above."To fix this error, try to install the libxml2-dev package.
Package: card-game-analysis
# Card Game Analysis: Tools to analyse card gamesThis project was started with the motivation of showing how unfair the card game Daifugo is. Please note that the project is under active development, and there’s still a lot of things to add.## Install/Update/Uninstall with [pip](https://pypi.org/project/pip/)The recommended way to install is by using [pip](https://pypi.org/project/pip/).### Install`shell $ pip installcard-game-analysis`### Update`shell $ pip install-Ucard-game-analysis`### Uninstall`shell $ pip uninstallcard-game-analysis`## DocumentationDocumentation is hosted on readthedocs.org:https://card-game-analysis.readthedocs.io/en/latest## Relevant links[Standard 52-card deck Wikipedia article](https://en.wikipedia.org/wiki/Standard_52-card_deck)[Daifugo Wikipedia article](https://en.wikipedia.org/wiki/Daifug%C5%8D)## LicenseCard-game-analysis is [MIT licensed](https://github.com/nwnordahl/card-game-analysis/blob/master/LICENSE).
Package: cardia
CardiaWelcome to Cardia, a Python-based library designed for building large AI-executable systems. Code cards, compact files containing a single class or function along with unit tests, serve as executable building blocks for AI agents, enabling them to execute tasks more efficiently.FeaturesEffortless System Building: Cardia simplifies the process of constructing large, AI-executable systems by breaking them down into manageable code cards.Intelligent Code Execution: The library enables AI agents to execute tasks with precision and efficiency, thanks to the modular nature of code cards.Seamless Code Transformation: Easily convert existing code into code cards, allowing for swift integration into your AI-powered projects.Enhanced Code Reusability: Code cards promote reusability, accelerating the development of complex systems and fostering collaborative coding practices.Robust Unit Testing Support: Each code card includes comprehensive unit tests, ensuring code integrity and reliability throughout development.InstallationYou can install Cardia using pip:pipinstallcardiaThis command will download and install the latest version of Cardia along with any required dependencies. If you want to keep Cardia up-to-date, simply run the same command with the --upgrade flag:pipinstallcardia--upgradeNow you're ready to start using Cardia to intelligently generate and manage your code cards.Disclaimer: This project is under active development. Please report any issues or suggestions you may have. Thank you!
Package: cardiac
CARDiACCode forAnisotropicRedshiftDistributionsinAngularClusteringCARDiAC is a python code that computes the impact of anisotropic redshift distributions on a wide class of angular
clustering observables, followingBaleato Lizancos & White 2023.At present, the code supports auto- and cross-correlations of galaxy samples and cosmic shear maps, including galaxy
-galaxy lensing. The anisotropy can be present in the mean redshift and/or width of Gaussian distributions, as
well as in the fraction of galaxies in each component of multi-modal distributions. Templates of these variations
can be provided by the user or simulated internally within the code.InstallationThe code can be installed simply by runningpython -m pip installDependencies:numpy,scipy,matplotlibastropyhealpypy3njcambnumbafor JIT compilation of galaxy lensing kernels, which are slow to compute otherwiseOptionally, galaxy-galaxy and galaxy-matter spectra can be obtained from a Lagrangian bias expansion using theanzucode if the user has it installed.UsageSeeTutorial.ipynbatthe code's repositoryon Github.AttributionIf you use the code, please citeBaleato Lizancos & White 2023.
Package: cardiac-geometries
Cardiac GeometriesThis is a library for creating idealized cardiac geometries in FEniCS usinggmsh.
Currently you can create bi-ventricular (BiV) and left-ventricular (LV) ellipsoidal geometries as well as slab geometries. There is also support for creating bi-ventricular and slab geometries embedded in a torso / bath.This package can also output analytic fiber orientations for LV and Slab and integrated with theldrbalgorithm BiV geometries.InstallUser are encourage to use the theprovided docker imagedocker pull ghcr.io/computationalphysiology/cardiac_geometries:latestwhich comes pre-installed with FEniCs and gmsh.You can also installcardiac-geometriesusingpippython3 -m pip install cardiac-geometriesbut this requires FEniCS and gmsh to be installed in other ways. See more athttps://computationalphysiology.github.io/cardiac_geometries/install.htmlGetting startedcardiac-geometriescomes with a command-line interface, and to e.g create an LV mesh you can docardiac-geometries create-lv-ellipsoid lv-meshThe same functionality can be accessed through the Python API, e.gimportcardiac_geometriesgeo=cardiac_geometries.mesh.create_lv_ellipsoid(outdir="lv-mesh")Seehttps://computationalphysiology.github.io/cardiac_geometries/quickstart.htmlfor more info.DocumentationPlease read the documentation athttp://computationalphysiology.github.io/cardiac_geometriesfor more info.ContributingSeehttps://computationalphysiology.github.io/cardiac_geometries/CONTRIBUTING.htmlLicenseMIT
Package: cardiac-mps
MPSA library for reading and analyzing MPS data.
The analysis scripts are heavily based onap_featureswhich is a package for computing features of action potential traces.InstallationTo install the package you can simply dipython -m pip install cardiac-mpsFor more options seehttps://computationalphysiology.github.io/mps/install.htmlUsageSeehttps://computationalphysiology.github.io/mps/demo.htmlDocumentationhttps://computationalphysiology.github.io/mpsContributingSeehttps://computationalphysiology.github.io/mps/CONTRIBUTING.htmlContactThis software is developed by Henrik Finsberg at Simula Research Laboratory.
If you need to get in contact, please send me an email athenriknf@simula.no.LicenseLGPLv2
Package: cardiffwaste
cardiffwasteAboutThis is a simple package to collect upcoming waste collections for an addresses served by Cardiff Council.Installationpip install cardiffwasteUsageGetting CollectionsGetting collections requires your Unique Property Reference Number (UPRN), the example below uses123456789012. If you don't know this (highly likely), you can use theaddress_searchhelper to look up the UPRN as decribedbelowfromcardiffwasteimportWasteCollectionsaddress=WasteCollections(123456789012)collections=address.get_next_collections()print(collections["general"]["collection_date"])# 2022-01-15Five collection types are currently handled, which aregeneral,recycling,food,gardenandhygiene. These keys will only be present if a collection is scheduled in the next 4 weeks. For scheduled collections, each collection will have the following keys:AttributeValue TypeDescriptiontypestrThe collection type (general,recycling,food, orgarden)collection_datedatetime.dateDate of next collectioncollection_typestrscheduledorrescheduleddepending on if planned has been missedimagestrURL of a representation of the collection typeAddress SearchYou can find your UPRN using theaddress_searchhelper. This takes any reasonable string describing the address, such as a post code, and returns a dictionary of possible matches. The returned dictionary is of the form{int(UPRN): str(address_description)}The helper can be called as follows:fromcardiffwasteimportaddress_searchaddress_search("CF10 1AA")# returns:# {10090717081: 'Flat 1, 22 St Mary Street, Cathays, Cardiff, CF10 1AA',#  10090717082: 'Flat 2, 22 St Mary Street, Cathays, Cardiff, CF10 1AA',#  10090717083: 'Flat 3, 22 St Mary Street, Cathays, Cardiff, CF10 1AA',#  10090717084: 'Flat 4, 22 St Mary Street, Cathays, Cardiff, CF10 1AA',#  10095459274: 'Managers Flat, Cardiff Cottage, 25 St Mary Street, Cathays,  Cardiff, CF10 1AA'}address_search("mansion house")# returns:# {10003566863: 'First Floor Flat, Mansion House, Richmond Road, Roath, Cardiff, CF24 3UN',#  10003566864: 'First Floor Rear, Mansion House, Richmond Road, Roath, Cardiff, CF24 3UN',#  10003566865: 'Second Floor, Mansion House, Richmond Road, Roath, Cardiff, CF24 3UN',#  200002933742: 'Mansion Shand House, 20 Newport Road, Adamsdown, Cardiff, CF24 0DB'}ContributingMy current plans are to get this to what might actually be called a stable state and sort out CI.
Package: cardify
Copyright (C) 2016  F. Brezo and Y. Rubio, i3visio[![Version in PyPI](https://img.shields.io/pypi/v/cardify.svg)]()
[![Downloads/Month in PyPI](https://img.shields.io/pypi/dm/cardify.svg)]()
[![License](https://img.shields.io/badge/license-GNU%20General%20Public%20License%20Version%203%20or%20Later-blue.svg)]()1 - DescriptionCardify is a GPLv3+ set of libraries developed by i3visio to work with credit card information.2 - License: GPLv3+This is free software, and you are welcome to redistribute it under certain conditions.This 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.This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.For more details on this issue, check the [COPYING](COPYING) file.3 - InstallationFast way to do it on any system:` pip install cardify `Under MacOS or Linux systems, you may need to do this as superuser:` sudo pip install cardify `This will manage all the dependencies for you.If you needed further information, check the [INSTALL.md](INSTALL.md) file.4 - Basic usageIf everything went correctly (we hope so!), it’s time for trying cardify by cheking if we can import it.` import cardify print cardify.__version__ `Now we can test the tool using the command line tool.` cardify_launcher.py-V1234123456785678 `Or we can try it using the library:` import cardify.utils as utils printutils.verifyCardNumber("1234123456785678")`5 - HackingIf you want to extend the functionalities of Cardify and you do not know where to start from, check the [HACKING.md](HACKING.md) file.6 - AuthorsMore details about the authors in the [AUTHORS.md](AUTHORS.md) file.
Package: cardilib
CardiAPCopyright ©2020-2021Velez Rueda, Garcia Smith, SommesePython library for performing biomedical images analysis. Cardilib allows users to easily work with images confocal microscopy, and obtain representative amplitude and kinetics data.Installation# Create and active a virtual env$python3-mvenv.venv
$source.venv/bin/activate# install the project$pipinstall-e.Running tests# install tox$pipinstalltox# execute tox$toxPublishing project# update package version in setup.cfg# them run these command:$gittag<version>
$gitpushoriginHEAD--tags# build the package$tox-ebuild# publish to test.pypi$tox-epublish# publish to pypi$tox-e--publish----repositorypypiUsing cardilib on lineYou can find a web server for using cardilib hosted in Binder. You can launchCardiAP here
Package: cardinality-cs110
Cardinality Estimation using the Flajolet-Martin algorithmImagine if you have data and you wish to know its cardinality (the number of unique elements present).Calcalating the cardinality can have multiple uses, e.g to count the number of unique visitors on a website.You could code a simple algorithm to loop through the dataset and check whether each element only occurs once or not, but this isn't feasible if you have a gigantic dataset with terabytes worth of data which can not even fit in your computer's memory. To solve this problem, one can use Cardinality Estimators which give a very close estimate of a dataset's cardinality at the cost of minimal memory usage.The Idea Behind itProvided that you have a large dataset, the probability of seeing a hashed item (converted to its binary form) which ends with anxamount of zeroes is2^x. For example, if you need 3 zeroes at the end, the probability is0.5 * 0.5 * 0.5 = 0.125because each bit is either a 0 or a 1. Hence, on average, you would get one number with 3 zeroes at the end out of1/0.5^xnumbers which is the equivalent of2^x. This is another simple method of estimating the cardinality, but it can give drastically inaccurate results if a hashed value has too many zeroes, and its estimates are in the power of 2 (256, 512, 1024...). One improvement on this method is to use various hash functions and average the estimates given to us, but a variety of hash functions is computationally expensive. To bypass this computational constraint, we can use a method called stochastic averaging where we divide the output of a single hash function into two parts. The number of buckets where we store the maximum number of 0's denoted bymand number of bits used to calculate which bucket we store our maximum number of 0's denoted byk. The accuracy of this algorithm, according to the paper it is based on, boils down to 1.3/sqrt(m) where m is the number of buckets so depending on the accuracy you want, you can vary the value of m but not to extremely large values. The reason being that your value ofk(which is the number of bits used in the hashed value to calculate the bucket index) is determined by log(m), and you don't want to use a large number of bits forkbecause it reduces accuracy. For example, if you have a binary value of 10000100000 and you use a value of 1024 for m, then you only get 1 as the maximum number of 0's instead of 5.An example of values for m/k for a binary input of 10010000 usingkas 2 would result in using the left 2 most bits to calculate the bucket number (10 corresponds to bucket no.2) and using the remaining bits to count the number of ending 0's (which are 4 in this case), and then storing the number of ending 0's in that bucket.Note: This algorithm produces predictably larger estimates; hence, to correct for the bias, the final output is multiplied by a constant of 0.79402 which was derived through statistical analyses by Mariannae Durand and Phillipie FlajoletUsageimportcardinality_cs110data=['sample data here']print(cardinality_cs110.flajolet_martin(data,k))'output is the estimated number of unique elements'
Package: cardio
Cardiocardiois a simple web-based viewer for 4D ('cine') medical imaging data.cardiois able to render sequences of mesh files (e.g.,\*.objfiles) and volume renderings of image files (e.g. *.nii.gz files).cardiois launched from the commandline and configured using a TOML file.Quickstart$python-mvenv.venv
$../.venv/bin/activate(.venv)pipinstallcardio(.venv)cardio--config./examples/cfg-example.toml

Apprunningat:-Local:http://localhost:8080/-Network:http://127.0.0.1:8080/
Package: cardiopy
CardiopyA flexibile package for R-peak detection and heart rate variability analysis of single-lead EKG data.Full documentation is availablehere. If you use CardioPy or a derivative in your work, please cite:Gottshall, J. L., Recoder, N., Schiff, N. D. (2020). CardioPy: An open-source heart rate variability analysis toolkit for single-lead EKG. boiRxv. doi: 10.1101/2020.10.06.328856How to use CardiopyCardiopy can be used in two ways:As a preprocessing module for the import and cleaning of clinical EKG data in conjuction
with HRV analyses by standard software packages.For this use, run through feature sets 1 and 2 (listed below). The exported '_nn.txt' file is compatible with all major HRV software packagesAs a stand-alone HRV analysis toolkit.For this use, continue through the workflow from feature set 1 through 4 (listed below). To ensure analytic reproducibilty, we highly recommend exporting cleaned nn detections at feature set 2.Features1. Data preprocessing and cleaningLoad single-lead EKG dataDetect R-peaks using the Pan Tompkins methodOption to detect R-peaks with flexible thresholding parameters for adjustment to noisy data and varying amplitudesOption to filter especially noisy data prior to peak detectionBuilt-in detection visualization methodsSimple artifact removal methods for manual inspection of detected peaks2. Export methods for cleaned peak detectionsCompatible with commonly used software such as Kubios HRV and Artiifact3. HRV analysis methodsStandard time-domain statisticsStandard frequency domain statisticsOption for Multitaper or Welch power spectral estimates4. HRV statistics exportSingle-file report exports in json formatMulti-file exports into .csv spreadsheets for group statisticsInstallationUse the package managerpipto install CardioPy.pipinstallcardiopyUsageBest when run with jupyter notebook. For detailed instructions download theexample jupyter notebook fileand theexample jupyter notebook file for manual cleaning, as well as thede-identified data segmentfromgithubFor optimal performance, close figure interactions ('off' button on the top right corner) when finished with each window.Parameter Optimization & Cleaning TipsRemove false interbeat intervals LAST, after all cleaning (addition/removal of peaks) has been done.To maintain integrity of the artifact logs:Only remove incorrectly added peaks with EKG.undo_add_peak NOT with EKG.rm_peak.Only re-add incorrectly removed peaks with EKG.undo_rm_peak NOT with EKG.add_peak.If R peak detections are not accurate, try:changing the moving window sizechanging the upshift percentagebothContributingPull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.LicenseBSD 3-ClauseRoadmapThe authors plan for future versions of CardioPy to include:Support for additional commonly used data formatsA graphical user interface
Package: cardlinky
cardlinky📘 Official documentationUsageFirstly, you need to create an account and а shop inhttps://cardlink.link/. After confirmation, you will be able to get a token and a shop ID to work with the API.Creating a bill and getting a payment link:fromcardlinkyimportCardlinkydefprint_bill_url(token:str,shop_id:str,amount:float)->None:# Creating an instance of the classcardlinky=Cardlinky(token)# Create a bill and save itbill=cardlinky.create_bill(amount=amount,shop_id=shop_id)# Getting a payment link and printingprint(bill.link_url)print_bill_url("YOUR-TOKEN","YOUR-SHOP-ID",100.0)# https://cardlink.link/link/GkLWvKx3Getting a bill status:fromcardlinkyimportCardlinkydefprint_bill_status(token:str,bill_id:str)->None:# Creating an instance of the classcardlinky=Cardlinky(token)# Create a bill and save itbill_status=cardlinky.get_bill_status(bill_id=bill_id)# Getting a status and printingprint(bill_status.status)print_bill_status("YOUR-TOKEN","BILL-ID")# Status.NEWInstallationpipinstallcardlinkyDependencies:PackageVersionrequests>=2.28.2