Saravanan666/pypi-org huggingface dataset:
Package: clin
ClinClinis a command-line utility to manageNakadiresources from schema files in "Infrastructure as Code" style.User GuidePrerequisitesPython>= 3.7InstallingYou can installclindirectly fromPyPIusing pip:pipinstallclinGetting startedAfter this you should be able to run theclintool:~clin--help
Usage:clin[OPTIONS]COMMAND[ARGS]...
...Please refer to thedocumentationandexamples.ContributingPlease readCONTRIBUTINGfor details on our process for submitting pull requests to us, and please ensure
you follow theCODE_OF_CONDUCT.PrerequisitesPython>= 3.7Poetryfor packaging and dependency
management. See theofficial docsfor
instructions on installation and basic usage.InstallingAfter cloning the repository, usepoetryto create a new virtual environment
and restore all dependencies.poetryinstallIf you're using an IDE (eg. PyCharm), make sure that it's configured to use the
virtual environment created by poetry as the project's interpreter. You can find
the path to the used environment withpoetry env info.Running the testspoetryrunpytestVersioningWe useSemVerfor versioning. For the versions available,
see thetags on this repository.AuthorsDmitry Erokhin@Dmitry-ErokhinDaniel Stockhammer@dstockhammerSee also the list ofcontributorswho participated in this project.LicenseThis project is licensed under the MIT License. See theLICENSEfile
for details.
Package: cli-nb2py
nb2pynb2pyis a comprehensive tool designed to convert Jupyter Notebooks (.ipynb files) into Python scripts (.py files). This tool simplifies the process of transforming interactive notebook cells into a structured Python script, automatically separating import statements and wrapping executable code within anif __name__ == '__main__':guard to maintain the script's portability and usability.This tool has two versions, acommand-lineversion based on python and avscode extension.FeaturesVSCode Extension: A one-click solution for converting notebooks to python files.Command-Line Simplicity: Offers a straightforward command-line interface for easy conversion of notebooks to Python scripts.Import Optimization: Automatically moves all import statements to the top of the generated Python script.Executable Wrap: Wraps all executable code within anif __name__ == '__main__':block, ensuring that the script can be imported without unintended execution.Markdown Conversion: Converts markdown cells into Python comments, preserving the notebook's documentation in the script.VSCode ExtensionInstallationYou can install thenb2pyextension directly from the Visual Studio Code Marketplace:Open VS Code.Navigate to the Extensions view by clicking on the Extensions icon in the Activity Bar on the side of the window.Search fornb2py. [if not found here is thelink]Click on the Install button.UsageAfter installation, open the Jupyter Notebook you wish to convert. You'll see a new icon in the editor title bar that looks like a Python logo. Click this icon to convert the currently open notebook.The converted Python script will be saved in the same directory as the notebook with the extension of.py.CLI ToolInstallationTo installnb2py, run the following setup script. Ensure you have Python 3.6 or later installed on your system.pipinstallcli-nb2pyUsageTo convert a Jupyter Notebook to a Python script, use the following command:nb2pyinput_notebook.ipynboutput_script.pyIf the output file name is not provided,nb2pywill generate a Python script with the same name as the input notebook (replacing the.ipynbextension with.py).Licensenb2pyis released under the MIT License. See theLICENSEfile for more details.ContactDeveloper: Bardia KhosraviEmail:bardiakhosravi95@gmail.comGitHub:https://github.com/BardiaKh/nb2py
Package: clincher
Clincherclincheris a tool for checking that all the commits in a git repo are signed, or if they're not that someone has signed something afterwards to backfill that.It implicitly trusts all the keys that are in the git repository, and dealing with keys that shouldn't be there is currently out of scope.Options--rev-spec: to check only the revisions in a git rev spec (as perhttps://git-scm.com/docs/gitrevisions#_specifying_ranges). Default is to check everything.--git-path: specify the root directory of the git repo (defaults to the current directory)--key-path: specify the keys path (default is "keys")--manual-signing-path: specify the manually signed commits path (default is "manually_signed")Trusted keysThekey-pathfolder contains a list of the GPG keys for all trusted users, which will be automatically imported by the tool. To export a key in the format we expect rungpg --export --armor <key id>(taking the key id fromgpg --list-keys) and write it to a file
inkey-pathending with ".gpg". We suggest using the users name and today's date to allow for identification and coping with expired keys.Please note that even if a key is expired, if it's been used to sign historical commits prior to it's expiry it should be kept, as otherwise you have a commit we don't know how to verify.Unsigned commitsIf a commit isn't signed, a file will be generated in themanual-signing-pathfolder corresponding to that commit. This is a representation of the commit that can be signed as a way to backfill the missing signing without editing the git history, and will be treated the same as the commit itself. It is named<git hash> - <author>.To sign the commit, use the followinggpg --sign --armor --detach-sign <commit file>This file should be named<git hash> - <author>.ascUploading new versions to PyPiWe useFlitfor uploading so the following worksFLIT_USERNAME="<pypi username>" FLIT_PASSWORD="<pypi password>" flit publish
Package: clinepunk
clinepunkPython Boilerplate contains all the boilerplate you need to create a Python package.Free software: MIT licenseDocumentation:https://clinepunk.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2022-01-22)First release on PyPI.
Package: clingo
This package provides CFFI-based bindings to the clingo solver.Clingo is part of thePotasscoproject forAnswer Set Programming(ASP).
ASP offers a simple and powerful modeling language to describe combinatorial problems aslogic programs.
Theclingosystem then takes such a logic program and computesanswer setsrepresenting solutions to the given problem.
To get an idea, check ourGetting Startedpage and theonline versionof clingo.Please check the theAPI documentationon how to use this module.
Package: clingo-lp
clingo[LP]clingo[LP]extends the ASP solverclingowith linear constraints as dealt with in Linear Programming (LP).InstallInstall via conda:condainstall-cpotassco-cconda-forgeclingo-lpCPLEXThe clingoLP propagator requires an LP solver.
The default islpsolvebutcplexcan be used optionally.IBM also provides a promotional version ofcplexthat is sufficient to solve small problems limited to 1000 variables and 1000 constraints.condainstall-cibmdecisionoptimizationcplex`To solve larger problems, you need to use the full version of CPLEX Studio.SyntaxLP constraints can be expressed as follows:LP constraintsClingoLP Syntaxw1x1+...+wnxn>= k&sum{w1*x1;...;wn*xn} >=kdomain(x)={l,...,u}&dom{l..u} =xmaximize: w1x1+...+wnxn&maximize{w1*x1;...;wn*x1}(minimize analogous)To avoid syntax clashes, you must quote"real numbers. Instead of1.5write"1.5".UsageclingoLP [number] [options] [files]

Options:

  --lp-solver=<arg>       : Set LP solver
      <arg>: {lps,cplx} (default lp-solver=lps)
  --[no-]show-lp-solution : Show LP solution and value of objective function
  --accuracy=n            : Set decimal position of LP solver accuracy (default accuracy=3)
  --epsilon=n,m           : Set epsilon to convert lhs > k into lhs >= k+n*10^-m (default epsilon=1,3)
  --[no-]trace            : Enables detailed output of theory propagation
  --core-confl=n          : Searches for core conflicts if at least n% of the theory atoms are decided
                            (default core-confl=20)
  --prop-heur=n           : Starts a solve call of the LP solver if at least n% of the theory atoms are decided
                            (default prop-heur=0)
  --[no-]ilp              : Sets the LP solver to solve an Integer Linear Programming (ILP) problemExample:clingoLP0--show-lp-solutionexample_encoding.lpexample_instance.lpFor more options you can ask for help as follows:clingoLP--helpPublicationClingo goes linear constraints over reals and integers, Janhunen, T., Kaminski, R., Ostrowski, M., Schellhorn, S., Wanko, P., Schaub, T. (2017),  TPLP, 17(5-6), 872–888.
Package: clingon
History0.3.2 (2022-10-02)Quickfix ofcollections.abc import Sequence0.3.1 (2020-12-14)Quickfix of DEBUG mode: now works on python 30.3.0 (2016-08-26)small functional change:
There is no more options default values from environment variables and configuration files.
Options default values are set once and only once into the decorated function definition.
Instead, options runtime values are set from environment variables, configuration files and cli,
in this order of priority (env vars have least priority, cli has highest).0.2.0 (2016-07-20)new feature: allow overloading of default values from configuration file (python, yaml, json)code refactor and additional commentsadded french and spanish defaults in user input utility class0.1.4 (2015-04-23)can override default options from environ, via variable CLINGON_PREFIX (see example2)utility class for user input management, with unittestsupdated READMEfix debug output ‘clize default parameters’some code refactoring0.1.3 (2015-03-27)fix list option when default is emptydefault value of boolean must be Falseif list option is given with non empty default, check number of argumentsnew example0.1.2 (2015-02-25)setup.py now installs clingon command,so, option auto_install as been removedrefactor error handling in script. There’s an exception RunnerErrorWithUsage
that prints single line usage string before error messsagebetter handle of duplicate short aliases0.1.1 (2015-02-24)update print_version()allow clingon to autoinstall in a more simpler waysome minor fixessome more unittests0.1.0 (2015-02-23)First release on PyPI.
Package: clingraph
clingraphAdeclarative visualizer for graphsdefined as a set of facts. The graphs are generated usinggraphvizbut are defined via fixed predicates that can be computed from logic programs.Graph defined by factsnode(clingraph).node(visual).node(asp).edge((clingraph,visual)).edge((clingraph,asp)).attr(node,clingraph,style,filled).VisualizationClingraph also containsspecial featuresfor integration withclingo, as well as for generatinglatexcode andgifs!Check out our paperhere. This work was published in LPNMR22 where it recived the"Best student paper award".UsageLook at ourdocumentation pageto see how to use clingraph.Try clingraph viacommand lineor as a package online in a jupyter notebook viaExamplesOurexamples foldershows how to use the range of functionalities in different applications.Examples used in the documentation (doc)Attribute definition(example1)Multi graphs(example2)Subgraphs(example3)Complex attributes(example4)Clingo integration with multi model(example5)Latex integration(example6)Simple (color,cube,lights)Clingo integration (sudoku,reify,transition_system)Absolute positioningLegendsLatex integrationDynamic applications (asprilo,elevator,minotaur)Clingo integrationMulti graphsAnimation via GifSVG interaction (family_tree,queens_interactive,minesweeper)Interaction using SVGVisualizing  thesolvingandprogram structureInstallationRequirementsPython (version 3.8, 3.9, or 3.10)For instructions to install from source, pip and conda see ourdocumentation page.
Package: clinguin
ClinguinClinguin enables ASP developers tocreate interactive User Interface(UI) prototypesusing only ASP.
UIs are defined as sets of facts,  which are then rendered by a fronted to provide continuous interaction with ASP solvers based on user-triggered events.Your UI definition would look like this!elem(w,window,root).elem(b1,button,w).attr(b1,label,"Button 1").when(b1,click,call,next_solution).UsageLook at ourdocumentation pageto see how to use clinguin.ExamplesOurexamples foldershows how to use the range of functionalities in different applications.ExtensionsIntegration with different applicationsClinguin includes a wide range ofclingofunctionalities such as multi-shot solving, theory solving and more! It also has extensions for interacting withclingraphgraphs and providing explanations.Is clinguin missing something for your application?No worries! Clinguin can be extended with different functionalities and even frontend languages, take a lookat this guide.InstallationRequirementsPython (version 3.8, 3.9, or 3.10)For instructions to install from source, pip and conda see ourdocumentation page.
Package: clingwrap
ClingwrapClingwrap is a simple debugging tool which collects information about the state of
a system and stores that information in a zip file for later analysis. It was
originally implemented for the Shaken Fist (https://shakenfist.com) project, but is
more generally useful than that.Clingwrap takes a configuration file (see examples/shakenfist-ci-failure.cwd for an
example), and processes the list of commands in that file to produce the zip file
of debugging output. The commands are specified in a simple YAML format, where
a configuration file looks like this:--
commands:
  - name: Kernel version and architecture
    destination: _commands/uname
    shell: uname -a

  - name: Installed system OS packages and versions
    destination: _commands/dpkg
    shell: dpkg -lPossible commands are:file commands: which record the contents of a file. For example:- name: syslog
    destination: var/log/syslog
    file: /var/log/syslogdirectory commands: which record all files in a given directory hierarchy, with a
possible simple exclusion regexp. For example:- name: Shaken Fist instances
    destination: /srv/shakenfist/instances
    directory: /srv/shakenfist/instances
    exclude: "hd[ac-z]"shell commands: which take a command line or script and execute them in a shell. A
valid configuration is:- name: Kernel version and architecture
    destination: _commands/uname
    shell: uname -ashell_emitter commands: which run a shell script which emits further commands to
execute. This is useful for finding objects and then storing information about them.
A valid example is:- name: Network namespaces
    shell_emitter: |
      for item in `find /var/run/netns -type f | sed 's/.*\///'`
      do
        echo "commands:
      - name: Network interfaces (namespace $item)
        destination: _commands/netns-$item/ip-link
        shell: ip netns exec $item ip link

      - name: Network addresses (namespace $item)
        destination: _commands/netns-$item/ip-link
        shell: ip netns exec $item ip addr

      - name: Network routes (namespace $item)
        destination: _commands/netns-$item/ip-link
        shell: ip netns exec $item ip route
      "
      done
Package: clingy
Clingy lets you save attachments from plain text emails.From the command line, you can use it like this:```clingy email1.txt email2.txt email3.txt```By default, the attachments will be saved into the current directory.You can specify a different directory using `-d` or `--directory` like so,and the directory will be created if it does not exist:```clingy email.txt -d out```You can save specific attachments using glob patterns (`-g` or `--glob`)and regular expressions (`-r` or `--regex`):```clingy email.txt -g "*.txt"clingy email.txt -r "^.+\.txt$"```When you `pip install clingy`, Python will create a platform-appropriateexecutable in the Python Scripts directory. Assuming you have that directoryin your path, you can just run `clingy` from the console.You can also use it as a library:```pythonimport clingy# List all attachments from an email fileclingy.find("email.txt")# List all attachments from an email stringwith open("email.txt") as file:clingy.find(file.read())# Save all attachments by filenameclingy.save("email.txt")# Save all attachments by stringwith open("email.txt") as file:clingy.save(file.read())# Save single attachment from email.message.Message objectattachments = clingy.find("email.txt")clingy.save(attachments[0])# Find all TXT files via glob pattern:clingy.find("email.txt", glob="*.txt")# Save all TXT files via regular expression:clingy.save("email.txt", regex=r"^.+\.txt$")```The combo glob/regex matcher is also available for good measure:```pythonimport clingyclingy.match("foo.txt", glob="*.txt")clingy.match("foo.txt", regex="\.txt$")````
Package: clinicadl
ClinicaDLFramework for the reproducible processing of neuroimaging data with deep learning methodsDocumentation|Tutorial|ForumAbout the projectThis repository hosts ClinicaDL, the deep learning extension ofClinica,
a python library to process neuroimaging data inBIDSformat.Disclaimer:this software isunder development. Some features can
change between different releases and/or commits.To access the full documentation of the project, follow the linkhttps://clinicadl.readthedocs.io/.
If you find a problem when using it or if you want to provide us feedback,
pleaseopen an issueor write on
theforum.Getting startedClinicaDL currently supports macOS and Linux.We recommend to usecondaorvirtualenvfor the installation of ClinicaDL
as it guarantees the correct management of libraries depending on common
packages:conda create --name ClinicaDL python=3.8
conda activate ClinicaDL
pip install clinicadlTutorialVisit ourhands-on tutorial web
siteto start
usingClinicaDLdirectly in a Google Colab instance!Related RepositoriesClinica: Software platform for clinical neuroimaging studiesAD-DL: Convolutional neural networks for classification of Alzheimer's disease: Overview and reproducible evaluationAD-ML: Framework for the reproducible classification of Alzheimer's disease using machine learningCiting usThibeau-Sutre, E., Díaz, M., Hassanaly, R., Routier, A., Dormont, D., Colliot, O., Burgos, N.: ‘ClinicaDL: an open-source deep learning software for reproducible neuroimaging processing‘, 2021.hal-03351976Routier, A., Burgos, N., Díaz, M., Bacci, M., Bottani, S., El-Rifai O., Fontanella, S., Gori, P., Guillon, J., Guyot, A., Hassanaly, R., Jacquemont, T.,  Lu, P., Marcoux, A.,  Moreau, T., Samper-González, J., Teichmann, M., Thibeau-Sutre, E., Vaillant G., Wen, J., Wild, A., Habert, M.-O., Durrleman, S., and Colliot, O.: ‘Clinica: An Open Source Software Platform for Reproducible Clinical Neuroscience Studies’, 2021.doi:10.3389/fninf.2021.689675Open Access version
Package: clinical-sectionizer
Clinical SectionizerThis package offers a component for tagging clinical section titles in docs.This package is deprecated!Development forclinical_sectionizerhas been moved tomedSpaCyand should now be installed as:pipinstallmedspacy# Option 1: Load with a medspacy pipelineimportmedspacynlp=medspacy.load(enable=["sectionizer"])print(nlp.pipe_names)# Option 2: Manually add to a spaCy modelimportspacyfrommedspacy.section_detectionimportSectionizernlp=spacy.load("en_core_web_sm")nlp.add_pipe(Sectionizer(nlp))Please see themedSpaCyGitHub page for additional information and documentation.
Package: clinical_trials
A Python API wrapper for the
[ClincalTrials.gov API](http://clinicaltrials.gov/ct2/info/linking).Documentation for [ClinicalTrials.gov can be found
here.](http://clinicaltrials.gov/ct2/info/linking)UsageTheTrialsclass only has two methods –searchanddownload. The
same information fromsearchis returned to thedownloadmethod in
ZIP file format.>>> from clinical_trials import Trials
>>> t = Trials()
>>> t.search("alzheimer's disease")>>> t.search('diabetes', 'cond')
>>> t.search('diabetes', 'condition')
>>> t.search(condition='diabetes')>>> # Specify the number of trials turned.
... t.search(intervention='Fluoxetine', count=200)>>> # Find trials no longer recruiting.
... t.search('lyme disease', recruiting='closed')>>> # If you want plain XML returned back.
... t.search(sponsor='NHLBI', output_format=None)>>> # You can also find trials by location -- up to 3 states or countries.
... t.search('cancer', state='TX')>>> t.search('diabetes', state1='TX', state2='NY', state3='CA')
>>> t.search(condition='lyme disease', country1='US', country2='CA')>>> # And you can download a ZIP file with the data.
... zip_file = t.download('cancer', count=500)CopyrightCopyright (c) 2011 Code for America Laboratories.See LICENSE for details.
Package: clinisift
clinisiftclinisiftis a multitool for processing clinical medical records.The main goal is to provide easy, off-the-shelf access tocommon NLP processeswhen working with medical records:Sentence TokenizationandSection Identificationfrom unstructured clinical textual dataNamed Entity Recognitionof medication-related data and clinical entities from recordsIntuitive visualizationof extracted informationSome motivating examples that can be accomplished in only a few lines of code to illustrate possible use-cases:Extract clinical problems and procedures mentioned in a record's CLINICAL HISTORY section.When exploring a new dataset, visualize records with clinical and medication entities parsed and highlighted on-the-fly.Check if both a particular medication and particular surgical procedure are mentioned in a patient's PAST MEDICAL HISTORY.Quick FeaturesParse- Extract clinical and medical entities through Transformers-based Named Entity Recognition, as well as other components like medical record section identification. Also supports any NER model that can be loaded as a HuggingFace pipelineAnalyze- Built-in methods to quickly filter through parsed data with as little code overhead as possible.Visualize- spaCy-based visualizer that integrates with Transformers NER to visualize medical record parses on-the-fly, programmatically or via command line.Get StartedInstallationInstall viapip:pip install clinisiftOr, from source:git clone git@github.com:clinisift/clinisift.git
cd clinisift && pip install -e .QuickstartFor a comprehensive overview of clinisift's capabilities, see the"Components" page on the wiki.Componentsclinisift is made up ofParserandDoccomponents. See the"Components" page on the wikifor an explanation of all the parameters.class Parser(
    models=None,
    include_ents=[],
    exclude_ents=[],
    iob_resolve=True,
    sent_tokenizer="clinitokenizer",
    sent_per_line=False,
    extract_section_headers=False,
    section_header_expr=None,
    device=None,
) 

class Doc(
    filepath_or_str,
    parser,
    is_file=True
)ExamplesBelow are some examples for common use-cases.Extract all clinical entities and medications from a *.txt filefrom clinisift.cliniparse import Parser
from clinisift.doc import Doc

parser = Parser() # med ner and clinical ner
doc = Doc(text_file_path, parser)

res = doc.parse()
# { "sentences": [...],
# "entities": [...l, }Visualize entities extracted on-the-fly from a directory of .txt filesTo launch a visualizer using the default Parser() config:From the command line:python -m clinisift.visualizer /my/data/dirA Flask server will be launched:The visualizer module can be integrated with any `Parser` for more customizability about the NER pipelines used, entities visualized, and so forth. More information is available in the wiki.
Package: clink
Component LinkDocumentation:https://askapsdp.gitlab.io/clink/CLINK is a Python library designed to make it easy to buildCloudEventconsumers and producers (CLINK
participants). It usesKombuandAMQPfor messaging.CLINK supports Python 3.6, 3.7, 3.8, 3.9, 3.10, and 3.11.InstallationInstall from thePython Package Index, (pypi), usingpip:python-mpipinstallclink