Saravanan666/pypi-org huggingface dataset:
Package: cgg
GGUF callerThis package is a GGUF (GPT-Generated Unified Format) file/model caller. Perfect to run in low end device(s).install the caller via pip/pip3 (once only):pip install cggupdate the caller (if not in the latest version) by:pip install cgg --upgradeuser manualThis is a cmd-based (command line) package, you can find the user manual by adding the flag -h or --help.cgg -hcheck current versioncgg -vconnector menucgg menugraphical user interface (GUI) callerSimple GUI to interact with a chat model for generating responses (recommended).call cpp connector:cgg cppcall c connector:cgg ccommand line interface (CLI) callerCLI input also provided for expert/advanced user(s).call gpp connector:cgg gppcall g connector:cgg gGGUF file(s) in the same directory will automatically be detected by the caller, hence, a selection menu will be shown in the console as below.metadata reader:You can check model metadata by:cgg rclone featurecgg clone [url]With this fast clone feature, you can clone any (GGUF model) file from URL, save it automatically in the current directory, and get it ready to connect locally (run it with your own machine offline); depends on the file size, as well as the network connectivity, it may take a while to complete the clone process; and you can see a dynamic progress bar showing the downloading status in this latest version. (an universal issue was detected for mac users: ssl cert. verify failed; possible solution: click Install Certificates.command under your Python version folder; details please refer toissuesreported)sample model(s) available to download (try out)For general purpose
[chat.gguf] (size: around 2GB or less)cgg clone https://huggingface.co/calcuis/chat/resolve/main/chat.ggufFor coding assistance
[code.gguf] (size: around 3GB or more)cgg clone https://huggingface.co/calcuis/code_mini/resolve/main/code.ggufFor health/medical advice
[medi.gguf] (size: around 3GB or more)cgg clone https://huggingface.co/calcuis/medi_mini/resolve/main/medi.ggufFor law/legal opinion
[law.gguf] (size: around 3GB or more)cgg clone https://huggingface.co/calcuis/law_mini/resolve/main/law.ggufFor wealth/financial plan
[finance.gguf] (size: around 3GB or more)cgg clone https://huggingface.co/calcuis/gguf/resolve/main/finance.gguf***those are all experimental models; no guarantee on qualitysample model listYou can either use the clone feature above or opt it straight from the lazy list by:cgg spdf analyzor (beta)You can load PDF into the model for analysis right away by (analyzor c):cgg pcOr by (analyzor p):cgg ppwebsite (alpha)gguf.us
Package: cg-gnn
cg-gnncg-gnn(short for "Cell Graph - Graph Neural Networks") is a library to train a graph neural network model on graphs built out of cell spatial data to predict patient outcomes or any other y-variable you choose. This library is designed to be used with theSpatial Profiling Toolbox (SPT), although independent functionality is also possible provided you can provide cell graphs in the same format as SPT(as implemented in thegraphssubmodule).In addition to standalone use,cg-gnnalso serves as an example implementation of an SPT-compatible graph neural network pipeline, for open source developers to reference when building their own deep learning tools that use cell graphs created by SPT. The key features that have to be implemented aremodel training and inferencecell-level importance score calculation
If the input and output schema is followed, your tool will be compatible with the SPT ecosystem, allowing users to easily integrate your tool into their SPT workflows and upload your model's results to an SPT database.This library is a heavily modified version ofhistocartographyand two of its applications,hact-netandpatho-quant-explainer.InstallationUsing pipIn addition to installing via pip,pip install cg-gnnyou must also install using the instructions on their websites,pytorchDGLCUDA(optional but highly recommended if your machine supports it)From sourceClone this repositoryCreate a conda environment that can run this software usingconda env create -f environment.ymlDockerFor convenience, Dockerized versions of this package are provided atnadeemlab/spt-cg-gnn. We recommend using the CUDA-enabled version, provided it will run on your machine.QuickstartUsespt graphs extractandspt graphs generate-graphsto create cell graphs from a SPT database instance that this python package can use.This module includes two scripts that you can call from the command line, or you can use the modules directly in Python.cg-gnn-traintrains a graph neural network model on a set of cell graphs, saves the model to file, and updates the cell graphs it was trained on with cell-level importance-to-classification scores if an explainer model type is provided.cg-gnn-separabilitycalculates class separability metrics given a trained model and other metadata.CreditsAs mentioned above, this repository is a heavily modified version ofthe histocartography projectand two of its applications:hact-netandpatho-quant-explainer. Specifically,Cell graph formatting, saving, and loading using DGL is patterned on how they were implemented in hact-netThe neural network training and inference module is modified from the hact-net implementation for cell graphsImportance score and separability calculations are sourced from patho-quant-explainerThe dependence on histocartography is indirect, through the functionality used by the above featuresDue to dependency issues that arose when using the version of histocartography published on PyPI, we've chosen to copy and make slight updates to only the modules of histocartography used by the features supported in this library.
Package: cghla
cghlaA set of tools that are useful for finding the MHC/HLA alleles for a given
sample using WGS, WES, or RNAseq data. In particular, these tools are designed for
the identification of MHC alleles to use in identification of novel peptides that can
be presented by MHC Class I proteins for finding presented neoepitopes in cancer.
As such, the specificity of the results are designed only for this purpose.These tools implement a particular workflow that assumes you have the following:bwa
samtools
ngsutilsjAdditionally, the tools are built to work with data from the IPD-IMGT/HLA database
which is available from:https://hla.alleles.orgFinally, final prediction can use MHC peptide binding affinities from mhcFlurry which
are available here:https://openvax.github.io/mhcflurry-motifs/mhcflurry.allele_sequences.csvThe basic workflow can be described as:WGSFind the location of HLA alleles in the reference genome.Extract flanking sequence from the reference genome, and adding this sequence
to the allele sequencesExtraction of mapped reads to the HLA locus in an already aligned BAM fileRe-alignment of these reads (optionally with unmapped reads as well) to the
now extended flanking HLA allele sequencesScore HLA allele pairs (maternal/paternal) to find the most likely genotypes
for the individual.Predict the most likely genotypesRNAseqThe RNAseq/WES workflow is similar, but instead of using the*_gen.fastaversions
of the IPD-IMGTR/HLA sequences you can use the*_nuc.fastaversions. When using these
coding mRNA sequence, you can skip steps 1 and 2. And instead of extracting a sub-set
of reads, you can align the raw FASTQ sequence. The scoring and prediction steps remain
the same.
Package: cgiauth
Includes the following classes:* `BasicAuth' which depends on web server "Basic" authentication* Cookie based classes `SessionCookieAuth' and `StatelessCookieAuth'* Hidden field based classes `SessionHiddenAuth' and`StatelessHiddenAuth'The Cookie and Hidden classes use JavaScript/SHA1 hashing to avoidsending passwords as clear text.Class constructor must be called BEFORE HTTP headers are output.All Authentication object constructors either return (possibly havingoutput cookie headers) or exit (having output a login form, or errormessage).cgiauth.py functions as a test if invoked as a CGI script, and as apassword file creator if invoked from the command line.Developed/tested under Python 2.5
Package: cgiFileUpload
AuthorRobert SudwartsFor uploading files via web interface.Basic scope of the problemFunctionality for:uploading large files using buffered chunksscaling down large imagesPackage Componentsupload.writefile() accepts a FieldStorage instance and writes in
buffered chunks to the specified directory.Image files can be written ‘as is’ or scaled to a specified size and
[at the same time] as a thumbnail image of a specified size.AThumbclass to check for existence of thumbnail/create/delete etcChange Logv.0.1.5 when scaling image to thumbnail image is given file extension .jpgv.0.1.4 added “Pillow>=2.0.0” as a dependency to setup.py.This package is required instead of PILv.0.1.3 added conditional ‘scale’ to writefile() so that this package can be used for all types of files (not just images)
Package: cgiproxy
CGI ProxySimple CGI HTTP Proxy.Sets theX-Forwarded-Forheader with the client IP address;Sets theUser-Agentheader with the client'User-Agentstring;Decodesgzip-ed content;Prints all errors tostderr;Usesurllib2for Python 2 andurllib.requestfor Python 3.InstallationInstall from PyPI usingpip:$pipinstallcgiproxyMethodsdo_get(url, headers=None)PerformsGETrequest.Arguments:url- The request URL asstr.headers- Optional HTTP request headers asdict.Returns:A tuple of(content, status_code, response_headers)do_head(url, headers=None)PerformsHEADrequest.Arguments:url- The request URL asstr.headers- Optional HTTP request headers asdict.Returns:A tuple of(content='', status_code, response_headers)do_post(url, data=None, headers=None)PerformsPOSTrequest. Converts query toPOSTparams ifdataisNone.Arguments:url- The request URL asstr.data- Optional HTTP POST data as URL-encodedstr.headers- Optional HTTP request headers asdict.Returns:A tuple of(content, status_code, response_headers)get_http_status(url, headers=None)Gets HTTP status code.Arguments:url- The request URL asstr.headers- Optional HTTP request headers asdict.Returns:An HTTP status code.get_response_headers(url, headers=None)Gets HTTP response headers.Arguments:url- The request URL asstr.headers- Optional HTTP request headers asdict.Returns:An HTTP response headers asdict.Examplesimportcgiproxystatus=cgiproxy.get_http_status('https://www.pageportrait.com/')print(200==status)headers=cgiproxy.get_response_headers('https://komito.net/')print(headers.get('content-type'))content,status,headers=cgiproxy.do_head('https://www.dtm.io/')print(''==content)print(200==status)print(headers.get('content-type'))content,status,headers=cgiproxy.do_get('https://www.dtm.io/',headers={'User-Agent':'Mozilla/5.0 (compatible; Darwin/18.2.0) cgiproxy/18.12','X-Custom-Header':'value'})print(''!=content)print(200==status)print(headers.get('content-type'))content,status,headers=cgiproxy.do_post('https://example.com/',data='aaa%3Dbbb%26ccc%3Dddd')print(''!=content)print(200==status)print(headers.get('content-type'))
Package: cgitize
cgitizeSelf-host your repositories using cgit.Supports cloning all of your repositories from major hosting providers:GitHub,Bitbucket,GitLab.Example output can be found athttps://git.tensin.name/.Installationpip install cgitizeUsagePass the path to the config tocgitize(/etc/cgitize/cgitize.toml by
default):cgitize --config path/to/cgitize.tomlSee an example config file atexamples/cgitize.toml.cgitize uses thegitexecutable, which might usesshinternally.
Make sure the required keys are loaded to a ssh-agent (or,preferably, use
access tokens/application passwords).DockerYou can runcgitizein a Docker container.
A separate image includes a web server with a configured cgit installation.Please seedocker/README.mdfor details.Mirror maintenanceUpdate the URL of an existing repository mirror:git remote set-url origin git@examples.com/username/name.gitDevelopmentSeeDEVELOPMENT.md.LicenseDistributed under the MIT License.
SeeLICENSE.txtfor details.
Package: cgiw
CGI WrapperThis is a lightweight, extensible framework for writing CGI scripts in python.Installpip install cgiwUseThis package takes care of parsing the query, headers and body (if post). It parses some basic mime types such asapplication/jsonandapplication/x-www-form-urlencoded, and allows the developer to use custom parsers. All handlers must return a tuple containing three items: the status string, a dictionary of headers, and the body. There are some basic response functions implemented to avoid having to construct this tuple from scratch.ExampleHere is an example that demonstrates the functionality of the framework.#!/bin/python3fromcgiwimportrunfromcgiw.responsesimportredirectfromcgiw.decoratorsimportwrap_headers,wrap_bodydefprocess_headers(headers):# do stuffreturnheadersdefprocess_body(body):# do stuffreturnbody@wrap_headers(process_headers)@wrap_body(process_body)defhandler(query,headers,body):# do stuffreturnredirect('/test',{'query':'string'})run(post=handler)
Package: cg-janus
JanusIn ancient Roman religion and myth, Janus ( JAY-nəs; Latin: Ianvs [ˈi̯aːnʊs]) is the god of beginnings, gates, transitions, time, duality, doorways, passages, frames, and endings. He is usually depicted as having two faces. The month of January is named for Janus (Ianuarius). Janus presided over the beginning and ending of conflict, and hence war and peace.
Package: cgkit1
cgkit1This is a fork of Matthias Bass's python-cgkit v1.2.0.It has been updated to be compatible with Python 3 and has the renderman and
noise generation code removed.Python Computer Graphics Kit v1.2.0Copyright (C) 2002, Matthias Baas (see license.txt)The Python Computer Graphics Kit is a collection of Python modules
that contain the basic types and functions to be able to create 3D
computer graphics images. The kit mainly focuses on Pixar's RenderMan
interface, but some modules can also be used for OpenGL programs or
non-RenderMan compliant renderers like POV-Ray, for example.Installing the packageThe package uses the Pythonbuild, so compiling and
installing looks the same on every platform, you simply have to call:python -m buildThis will compile the C-modules and install everything in the standard
location.The cgtypes module uses Cython.
Package: cgli
cgliA utility to use a python program from both command line (cli) as website (cgi)InstallationUse pip to installcglipip install cgliUsageExample script:# import the application_make# and application_execute functions# from the cgli modulefromcgliimportapplication_maker,application_execute# define the argumentsarguments={'string':{'short':'s','help':'a string'},'number':{'short':'n','help':'a number','type':int},'another':{'short':'a','help':'another number','default':42,'type':int},}# define a function with the arguments defined abovedefsome_function(string,number,another):# do somethingsum=number+another# return somethingreturn{'string':'The string is%s'%string,'number':'The number is%d'%number,'sum':sum,}# make the application and execute itapplication_execute(application_maker(some_function,arguments))Command lineShow arguments:$ ./example.py -hUse arguments (long and short attribute names can be combined):$ ./example.py -s"Hello World" --number 3WebserverShow arguments:http://example.com/example.py?hUse arguments (only long attribute names can be used)http://example.com/example.py?string=Hello+World&number=3
Package: cgm
Causal Graphical ModelsA python library for building causal graphical models, closely following Daphne
Koller's Coursera course on Probabilistic Graphical Models, and her 2009 bookProbabilistic Graphical Models: Principles and Techniques.
The source for this project is availablehere.InstallationNumPyis the only dependency. Python version must be >= 3.7.pip install cgmUsageimportnumpyasnpimportcgmnp.random.seed(30)# Define all nodesA=cgm.CG_Node('A',nStates=3)B=cgm.CG_Node('B',3)C=cgm.CG_Node('C',3)D=cgm.CG_Node('D',3)# Specify all parents of nodescgm.CPD(child=B,parents=[A])cgm.CPD(C,[B])cgm.CPD(D,[A,B])# Create causal graphgraph=cgm.CG([A,B,C,D])
Package: cgm-3d-cnn
cgm_3d_cnn - A tool that predicts protein structure from short and long-range contactsAnastasiya V. Kulikova and Claus O. WilkeOverviewDescription in progress. Package in progress.InstallationYou can install cgm_3d_cnn with pip:pipinstallcgm_3d_cnnTo install cgm_3d_cnn along with the tools to develop and run tests, run the following in your virtual environment:pipinstall-e.[dev]
Package: cg-maven
MavenMaven:"one who is experienced or knowledgeable."This repository holds the software interacting with the maven database. Maven is currently a work in progress.AimsThe maven database will be used to store quality metrics for cases and their analysis that come through Clinical Genomics.Developing MavenSteps to start developing on Maven locally:Clone the repogitclonehttps://github.com/Clinical-Genomics/mavenCreate a working environmentRequires poetry to be installed:https://python-poetry.org/docs/2a. Create a virtual python environment in the directory# Go into the directorycd./maven# Create a virtual environmentpython3-mvenvmaven# Activate the virtual environmentsourcevenv/bin/activate# Install packagespoetryinstall2b. If you are using pycharm setup apoetry interpreterhttps://www.jetbrains.com/help/pycharm/poetry.html#poetry-pyprojectInstall a mongodb client locally (for now) follow steps outlined herehttps://www.mongodb.com/docs/v7.0/tutorial/install-mongodb-on-os-x/#install-mongodb-community-editionStart a mongo server locally that runs the databasebrewservicesstartmongodb-community@7.0to stop the service when wantedbrewservicesstopmongodb-community@7.0To establish a connection to the database with FastApi and uvicorn run:python3-muvicorn--reload--app-dir./apimain:appIf this step worked you should see "Connected to database." in the terminalTo view the database in Compasshttps://www.mongodb.com/products/tools/compassSetup a connection to the localhostCreate a new database called "maven"Alternatively to the steps above one can also run maven using docker
7a. Install docker and start the docker application:https://docs.docker.com/engine/install/After step 1cd./maven
dockercomposeup
Package: cgminerhttpinterface
CGMiner HTTP InterfaceA basic HTTP endpoint to any API conforming to the CGMiner RPC interface.InstallationFrom pip:$ pip install cgminerhttpinterfaceUsageMost people will just want to run the server, which means a simple command in
your shell / command prompt:$ chi-serverThis will start an HTTP server reachable on all interfaces on port 8080, which
will re-issue incoming requests to localhost:4028 (the default host:port for
the CGMiner RPC API.)  This server can be started at any time, but will of
course only be useful once the CGMiner API has been started.Optionsusage: chi-server [-h] [-w HTTP_PORT] [-p API_PORT] [-a API_HOST]

Start HTTP interface to the monitoring API

optional arguments:
  -h, --help            show this help message and exit
  -w HTTP_PORT, --http_port HTTP_PORT
                        Port to use for http server
  -p API_PORT, --api_port API_PORT
                        Port used by API server
  -a API_HOST, --api_host API_HOST
                        Host name/address used by API serverUsing the HTTP InterfaceURL structure ishttp://<host>[:port]/<command>[+command…]/[parameter]. For
example:http://localhost/summary+pools/: combined summary and pools report on the
default porthttp://localhost:8081/gpu/0: single gpu status on port 8081 (as defined in
the command line)Visiting the server root (e.g.http://localhost/) will issue the compound
‘summary+devs’ command.At this point in time, the HTTP endpoint will simply serve the response of the
API as is - meaning a JSON formatted data structure containing sections for each
command issued. All commands available via theCGMiner APIare also available
via the HTTP endpoint - in fact the HTTP endpoint performs no command validation
at all, relying on the API to validate requests and respond appropriately.
Package: cgm-ml-common
Child Growth Monitor Machine LearningChild Growth Monitor (CGM)is a game-changing app to detect malnutrition.
If you have questions about the project, reach out toinfo@childgrowthmonitor.org.This is the Machine Learnine repository associated with the CGM project.IntroductionThis project uses machine learning to identify malnutrition from 3D scans of children under 5 years of age.
Thisone-minute videoexplains.Getting startedRequirementsYou will need:Python 3.6 or Python 3.7TensorFlow version 2other librariesTo install, run:pipinstall-rrequirements.txtWe useMicrosoft Azure MLto manage our datasets, experiments, and models internally.
You can also run most of the code without AzureML though.Dataset accessData access is provided on as-needed basis following signature of the Welthungerhilfe Data Privacy & Commitment to
Maintain Data Secrecy Agreement. If you need data access (e.g. to train your machine learning models),
please contactMarkus Matiaschekfor details.If you have access to scan data, you can use:cgmml/data_utilsto understand and visualize the data.Repository structureThe source code is incgmml/.Due to AzureML, all code for a single experiment run needs to reside in one directory.
Example: All code for one specific training, e.g. a ResNet training, needs to be in this training directory.However, many of our trainings (and also evaluation runs) share large portions of code.
In order to reduce code duplication, we copy shared(a.k.a. common) utility code withcopy_dir()fromcgmml/common/into the training/evaluation directory.
This way, during the experiment run, the code is in the directory and can be used during the run.Run linting / tests# Make sure to be in the root dir of this repositoryflake8cgmml/
pytestRelease cgm-ml-commonCommon functionalities of this repo are released on pypi:https://pypi.org/project/cgm-ml-common/To release a new version of cgm-ml-common:Configure the version you wish to release insetup.pyPublish the release using the pipeline.github/workflows/pypi-release.ymlContributingPlease seeCONTRIBUTING.mdfor details.VersioningOurreleasesusesemantic versioning.
You can find a chronologically ordered list of notable changes inCHANGELOG.md.LicenseThis project is licensed under the GNU General Public License v3.0. SeeLICENSEfor details and refer toNOTICEfor additional licensing notes and use of third-party components.
Package: cgmodels
cgmodelsLibrary that work as an interface between services at Clinical Genomics.
In most cases where multiple services needs access to a common API, those models should be defined here.UsageCurrentlycgmodelssupport contracts for the following applications:crunchydemultiplexInstallationPypipip install cgmodelsGithubInstallpoetrygit clone https://github.com/Clinical-Genomics/cgmodels
poetry install
Package: cgmquantify
cgmquantify: python package for analyzing glucose and glucose variabilityContinuous glucose monitoring (CGM) systems provide real-time, dynamic glucose information by tracking interstitial glucose values throughout the day. Glycemic variability, also known as glucose variability, is an established risk factor for hypoglycemia (Kovatchev) and has been shown to be a risk factor in diabetes complications. Over 20 metrics of glycemic variability have been identified.Here, we provide functions to calculate glucose summary metrics, glucose variability metrics (as defined in clinical publications), and visualizations to visualize trends in CGM data.User GuideIssue TrackingInstallation:Recommended:pip install cgmquantifyIf above does not work: pip install git+git://github.com/brinnaebent/cgmquantify.gitgit clonerepoDependencies: (these will be downloaded upon installation with pip)pandas, numpy, matplotlib, statsmodels, datetimeComing soon -Currently only supports Dexcom CGM, more CGM coming soonIntegration with food logs, myFitnessPal food logsMachine Learning methods for discovering trends in CGM data