Saravanan666/pypi-org huggingface dataset:
Package: csxhair
CSXhairCSXhair is a simple package for decoding/encoding CS:GO (and CS2!) crosshairs using share codes.fromcsxhairimportCrosshairmy_crosshair=Crosshair.decode('CSGO-ZEw8O-KGXNu-4TTUU-VyXbD-SBCtG')print(my_crosshair.gap)# -3.0my_crosshair.size+=5my_crosshair.recoil=True# exclusive to CS2print(my_crosshair.encode())# CSGO-hbBNp-7jd43-34SWO-9ck6v-p4FyBprint(my_crosshair.csgo_commands)# ['cl_crosshairgap -3.0', ..., 'cl_crosshairdot 0', ...]print(my_crosshair.cs2_commands)# ['cl_crosshairgap -3.0', ..., 'cl_crosshairdot false', ...]
Package: csync
UsageCreatewatcherConfig.txtthat contains entries like:[project_name]
local_dir = /your/local/path
remote_dir = /your/remote/path
remote_addr = username@server
remote_port = {port}

[project_name]
local_dir = /your/local/path
remote_dir = /app
remote_addr = {username@server|server}
languages = {c++|all}
ignore_filetypes = {.so*|.so*,.cpp...}
file_delete = {True|False}Language, remote_port, ignore_filetypes are optionalignore_filetypesis useful if you have embedded c++ code in your project and the machine you're syncing to isn't the same type of machine as the one you're developing on.Thealllanguage will sync the entired directory over. By default the language ispythonfile_deletewill default to True, but if set to False will not delete files on remote if they don't exist on local. This is useful for building env-specific stuff that you don't want overwritten by a different env (or if you don't build on local because you can't or something).servercan be an alias set in your~/.ssh/configcysncusesrsyncevery time a change to a local_dir is made.Installationpip install csyncTODOHave codeSync create the config files for youExtend makefile commands so thatmakeisn't the only oneEnable force-syncSync both ways
Package: cs.zestreleaser.changelog
Using the features available at zest.releser.lasttaglog this module
fills the CHANGES file using the VCS’s log command.Actual implementation only works with git. To add support to other VCSs you need to add new conditions to theprettyfy_logsmethodDevelopingCreate a virtualenv somewhere:$ virtualenv .
$ source bin/activateInstall zc.buildout:$ pip install zc.buildoutRun buildout:$ ./bin/buildout -vvLatest zest.releaser with the developing version of cs.zestreleaser.changelog will be installed and available through all the scripts created in bin folder.
So you can run bin/fullrelease for instance.Changelog1.1 (2021-02-02)Prettify svn log messages.
[erral]1.0.1 (2020-07-13)Tag commands should be lists.
[erral]1.0 (2020-07-13)Error control for missing tags
[erral]Change svn base class
[erral]0.8 (2020-02-24)Changes due to changes in zest.releaser latest version
[uodriozola]0.7 (2015-10-02)Unicode support for changelog entries [erral]0.6 (2015-10-01)Fix changelog update :(.0.5 (2015-09-30)fix history checking [Mikel Larreategi <mlarreategi@codesyntax.com>]0.4 (2015-09-24)use print as function [Mikel Larreategi <mlarreategi@codesyntax.com>]get all commits when no tags are found [Mikel Larreategi <mlarreategi@codesyntax.com>]documentation and buildout update [Mikel Larreategi <mlarreategi@codesyntax.com>]hook changelog filler before the preleaser, because now zest.releaser checks for ‘not changes yet’ before the middle hook is run [Mikel Larreategi <mlarreategi@codesyntax.com>]0.3 (2015-05-25)Update import to be compatible with zest.releaser >= 40.2 (2014-12-12)Show all the commits made since the last tag to the user before asking anything.0.1 (2014-12-12)Initial implementation: asks the user if he wants to add the last commits made since the last tag to the CHANGES file. This initial implementation works only with git.
Package: cs.zestreleaser.eggbuilder
cs.zestreleaser.eggbuilderCreate egg files if the user wantsWe have a client that uses some old deployment scripts that needs *.egg files to complete
the deployment.So using this zest.releaser plugin we can build egg files automatically for the package
we are relasing.LicenseThe project is licensed under the GPLv2.ContributorsMikel Larreategi,mlarreategi@codesyntax.comChangelog1.0.1 (2020-10-29)Fix readme markup.
[erral]1.0 (2020-10-28)Initial release.
[]
Package: cs.zestreleaser.upload
This package provides a plugin forzest.releaserthat offers to upload the
released egg via SCP, SFTP or HTTP(S) PUT (WebDAV) to a custom location (instead of or
in addition to PyPI).This plugin is based ongocept.zestreleaser.customuploadto do the upload process
and uses thedistbaseanddistdefaultconcept ofjarn.mkrelease, so you need to
add something like this to your~/.pypirclike the following:[cs.zestreleaser.upload]
_default_with_input_ = scp://download.gocept.com//var/www/customers/
_default_ = scp://download.gocept.com//var/www/packagesIf the option_default_with_inputis set, the script will ask the user a folder name
that will be appended to the setting, and the created egg will be uploaded there and the
script will finish there.This option is useful if you have a folder where you have one folder per project/customer
in the same place.If the option_default_with_input_is not set and_default_is set, the script will
upload the egg to that destination. This is usefull as a default destination of your eggs.Options for HTTP(S) PUT (WebDAV)This option is the same as ingocept.zestreleaser.customuploadso
HTTP(S) PUT (WebDAV) is implemented usingcurlto add options tocurl,
e. g. to disable certificate checks, add the options in front of the URL
like this:[cs.zestreleaser.upload]
gocept.special = --insecure https://dav.gocept.com/specialDevelopmentThe source code is available in the git repository athttps://github.com/codesyntax/cs.zestreleaser.uploadPlease report any bugs you find athttps://github.com/codesyntax/cs.zestreleaser.upload/issuesChangelog2.0 (2020-02-26)Python3 support [erral]1.0 (2014-11-07)Initial implementation [erral]
Package: cszp
cszp Easy soccer execution program日本語ページはこちらDownloadNote This program is premised on running on linux (Debian system). So it may not run on other OS.Operation check OSubuntu 16.04LTSubuntu server 16.04LTSdebian 10.1zorinos 15.2ubuntu 18.04LTSubuntu 20.04LTSHow to installpip3 install cszpBugs, features you want to addHere!
Package: ctable
CURSES TABLESusage: ctable [-h] [--columns COLUMNS [COLUMNS ...]] data

Display a typical API json object (a list of dictionaries) in a curses table.

positional arguments:
  data                  json data.

optional arguments:
  -h, --help            show this help message and exit
  --columns COLUMNS [COLUMNS ...], -c COLUMNS [COLUMNS ...]
                        Specify which fields you want to translate into columns.Keybindingsj, n, down  : Move down a row.
k, p, up    : Move up a row.
f, d, pgdn  : Move down a page.
b, u, pgup  : Move up a page.
g, <, home  : Go to first row.
G, >, end   : Go to last row.
v, i, enter : View row data.
q, x, escape: Exit.
Package: ctail
ctail = colored tailctail is a command line script used to show the last lines of a file adding color to provided regular expressions.ctail$ ctail -h
usage: ctail [-h] [-d] [-l NLINES] [-f] [-s] file_path [reg_exes [reg_exes ...]]

positional arguments:
  file_path           path of the file
  reg_exes            regular expressions to colour on the file (default: None)

optional arguments:
  -h, --help          show this help message and exit
  -d                  color date times in format: yyyy-mm-dd HH:MM:SS (default: False)
  -l NLINES           how many last lines show from file (default: 10)
  -f, --follow        output appended data as the file grows (default: False)
  -s, --show-regexes  show applied regular expresions (default: False)Installpip install ctail
Package: ctakesclient
Purpose: Extract Medical Concepts from Physician NotesThis package simplifies communication with cTAKES NLP servers which produce matches with UMLS Concepts.Clinical Text and Knowledge Extraction System (cTAKES)Unified Medical Language System (UMLS)QuickstartClinical text fragment or entire physician note.physician_note='Chief Complaint: Patient c/o cough, denies fever, recent COVID test negative. Denies smoking.'output=awaitctakesclient.client.post(physician_note)Note thatctakesclientuses an async API.
If your code is not async, you can simply wrap calls inasyncio.run():output=asyncio.run(ctakesclient.client.post(physician_note))OutputThis client parses responses into lists of MatchText and UmlsConcept.CtakesJSON(output)

list_match() -> List[MatchText]

list_concept() -> List[UmlsConcept]

list_sign_symptom() -> List[MatchText]

list_disease_disorder() -> List[MatchText]

list_medication() -> List[MatchText]

list_procedure() -> List[MatchText]

list_anatomical_site() -> List[MatchText]MatchText: Physician NotesMatchText(s) are the character positions in the physician note where a UmlsConcept was found.MatchText: PolarityUMLS ConceptUMLS VocabularyUMLS Semantic Types and GroupsYou can browse thelist of UMLS Semantic Typesat the National Library of Medicine.
Package: ctakes-parser
Py CTakes ParserPython utilities to parse the output of cTAKES 4.0.Repository is a port of the Julia repository found here -https://github.com/bcbi/CTakesParser.jlInstallationFrom PyPipipinstallctakes_parserFrom Github Masterpipinstallgit+https://github.com/titu1994/PyCTakesParser.gitExamplesParse Single Fileimportctakes_parserasparserdf=parser.parse_file(file_path='notes_in/mts_sample_note_97_1152.txt.xmi')Parse Entire Directoryimportctakes_parserasparserparser.parse_dir(in_directory_path='notes_in/',out_directory_path='notes_out/')
Package: ct-analyser
ct_analyserVisualising and Extracting Data from Axial Chest CT ScansThe CT analyser (CTA) package is a module developed to enable users to load in and process medical images, specifically DICOM (.dcm) files of axial CT scans. This package is available to install from PyPi usingpip install(Available fromhttps://pypi.org/project/ct-analyser/0.1.2/).Main FeaturesOnce imported, CTA offers several functions to threshold and mask the images in order to isolate key structures (such as the heart or lungs) or regions of interest. Finally, key data relating to the regions of interest including the volume, dimensions and tissue type can be produced.Vision for ct_analyserUltimately, this package offers the foundation for further applications, both in medical settings as an aid for radiologists, or in training to extract example structures from real images for the teaching of students or even as a basis for processing data inputted into machine learning models for automated diagnostic tools.Getting startedThe module can be installed with:`pip install ct-analyser==0.1.2`
Package: ctapipe
Low-level data processing pipeline software forCTA(the Cherenkov Telescope Array)This is code is a prototype data processing framework and is under rapid
development. It is not recommended for production use unless you are an
expert or developer!Code:https://github.com/cta-observatory/ctapipeDocs:https://ctapipe.readthedocs.io/Slack: Contact Karl Kosack for inviteCiting this softwareIf you use this software for a publication, please cite the Zenodo Record
for the specific version you are using and our latest publication.You can find all ctapipe Zenodo records here:List of ctapipe Records on Zenodo.There is also a Zenodo DOI always pointing to the latest version:At this point, our latest publication is the 2021 ICRC proceeding, which you can
cite using this bibtex entry:@inproceedings{ctapipe-icrc-2021,
    author = {Nöthe, Maximilian  and  Kosack, Karl  and  Nickel, Lukas  and  Peresano, Michele},
    title = {Prototype Open Event Reconstruction Pipeline for the Cherenkov Telescope Array},
    doi = {10.22323/1.395.0744},
    booktitle = {Proceedings, 37th International Cosmic Ray Conference},
    year=2021,
    volume={395},
    number={744},
    location={Berlin, Germany},
  }Installation for Usersctapipeand its dependencies may be installed using theAnacondaorMinicondapackage system. We recommend creating a conda virtual environment
first, to isolate the installed version and dependencies from your master
environment (this is optional).The latest version ofctapipecan be installed via:mamba install -c conda-forge ctapipeor via:pip install ctapipeNote: to install a specific version of ctapipe take look at the documentationhere.Note:mambais a C++ reimplementation of conda and can be foundhere.Note this ispre-alphasoftware and is not yet stable enough for end-users (expect large API changes until the first stable 1.0 release).Developers should follow the development install instructions found in thedocumentation.
Package: ctapipe-io-lst
ctapipe_io_lstEventSource Plugin for ctapipe, able to read LST zfits files
and calibration them to R1 as needed for ctapipe tools.Since version 0.19,ctapipe_io_lstis on conda-forge,
which is the easiest way to install it, since theprotozfitsdependency is offered pre-compiled for Linux and mac OS (including arm64).To install into an exisiting environtment, just do:# or conda
$ mamba install -c conda-forge ctapipe_io_lstFor development, create a new environment and run the development install:conda env create -n lstenv -f environment.yml
conda activate lstenv
pip install -e .ctapipe_io_lstis also on PyPI, but note that theprotozfitsdependency only has wheels for Linux, so you'd need to compile
from source on mac OS.Test DataTo run the tests, a set of non-public files is needed.
If you are a member of CTA, ask one of the project maintainers for the credentials
and then run./download_test_data.sh
Package: ctapipe-io-nectarcam
EventSource Plugin for ctapipe, able to read NectarCam zfits files
and calibrate them to R1 as needed for ctapipe tools.To install into an existing environment, just do:pipinstall.For development, create a new environment and run the development install:condaenvcreate-nnectar-dev-fenvironment.yml
condaactivatenectar-dev
pipinstall-e.
Package: ctaplot
ctaplot provides low-level reconstruction quality-checks metrics computation and vizualisation for Imaging Atmospheric Cherenkov Telescopes such as CTAYou may find examples in thedocumentationand run them via mybinder.Code :https://github.com/cta-observatory/ctaplotDocumentation :https://ctaplot.readthedocs.io/en/latest/Author contact: Thomas Vuillaume -thomas.vuillaume@lapp.in2p3.frLicense: MITThe CTA instrument response functions data used in ctaplot come from the CTA Consortium and Observatory and may be found on thecta-observatory website.In cases for which the CTA instrument response functions are used in a research project, we ask to add the following acknowledgement in any resulting publication:“This research has made use of the CTA instrument response functions provided by the CTA Consortium and Observatory, seehttp://www.cta-observatory.org/science/cta-performance/(version prod3b-v2) for more details.”InstallRequirements packages:python > 3.6numpyscipy>=0.19matplotlib>=2.0astropyWe recommend the use ofanacondaThe package is available through pip:pipinstallctaplotexportGAMMABOARD_DATA=path_to_the_data_directoryWe recommend that you add this line to your bash source file ($HOME/.bashrcor$HOME/.bash_profile)GammaBoardA dashboard to show them all.GammaBoard is a simple jupyter dashboard thought to display metrics assessing the reconstructions performances of
Imaging Atmospheric Cherenkov Telescopes (IACTs).
Deep learning is a lot about bookkeeping and trials and errors. GammaBoard ease this bookkeeping and allows quick
comparison of the reconstruction performances of your machine learning experiments.It is a working prototype used especially by theGammaLearnproject.Run GammaBoardTo launch the dashboard, you can simply try the command:gammaboardThis will run a temporary copy of the dashboard (a jupyter notebook).
Local changes that you make in the dashboard will be discarded afterwards.GammaBoard is using data in a specific directory storing all your experiments files.
This directory is known under$GAMMABOARD_DATAby default.
However, you can change the path access at any time in the dashboard itself.DemoHere is a simple demo of GammaBoard:On top the plots (metrics) such as angular resolution and energy resolution.Below, the list of experiments in the user folder.When an experiment is selected in the list, the data is automatically loaded, the metrics computed and displayed.
A list of information provided during the training phase is also displayed.
As many experiments results can be overlaid.
When an experiment is deselected, it simply is removed from the plots.CiteWe would appreciate you cite the version of ctaplot you used using the corresponding Zenodo DOI that cound find here:https://doi.org/10.5281/zenodo.5833853
Package: ctat
Cell Type Annotation ToolsThis repository provides schema of the cell type annotation and related data standardization operations.InstallationInstall the latestpypi packagethrough following the instructions in the pypi page.Configuration SpecConfiguration spec defines schema for the CTA data conversion config files. Latest schema is located at:ctat_schema.yamlOperationsCell Type Annotation Tool provides the following operations:ValidateThe provided YAML/YML configuration file is validated against the Cell Type Annotation Schema.ctat validate -i /path/to/my_config.yamlIf config is valid, program exits with system code 0, otherwise logs the issues and exits with a non-zero code.FormatFormats the given data into standard cell type annotation data structure using the given configuration. Output is persisted as a json file.ctat format -i /path/to/my_data.tsv -c /path/to/my_config.yaml -o /path/to/output.jsonFields that are not mapped in the config file are stored asuserAnnotations.A sample configuration file can be found attest_config.yaml. After applying this config tothe user data, sample output file can be found attest_result.json.
Package: ct-aws-eb-cleaner
Cinnecta - AWS Elastic Beanstalk CleanerPython project to clear all applications versions from an ElasticBeanstalk environment that are not implemented.RequirementsAWS client (https://aws.amazon.com/pt/cli/) installed and configured in the host machine where the application will run.Featuresct_aws_eb_cleaner –application-name APPLICATION_NAMEMain module to execute the cleaner procudere.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2019-07-30)First release on PyPI.
Package: ct-clock
ct_clockcurses terminal digital clockInstallpip install ct-clockTo Usect-clockto use the clockct-clock stop_watchto use the stop watchCommandsClock Commands:qquitsshow secondsm24 Hour ClockcMode: normal, cycle wholebBlink coloneShow DateECycle date formatsnToggle colondReset settings to default123Cycle mode timing (1 every sec, 2 every min, 3 every hour)rtyuiop[Select digit color: Red, Green, Blue, Yellow, Magenta, Cyan, White, BlackRTYUIOP{Select background color: Red, Green, Blue, Yellow, Magenta, Cyan, White, BlackStop Watch Commands:qquitgStart or pause stop watchhReset stop watch to 00:00:00rtyuiop[Select digit color: Red, Green, Blue, Yellow, Magenta, Cyan, White, BlackScreen Shotsno seconds24 hour clockStop Watch
Package: ct-core-db
CT Core DB – Catalant Core DB Framework.The main features available in this framework include:TheSQLAlchemytoolkit with our customizations and enhancementsCommands for versioning and managingMySQLdatabase schemasDebugging and development utilities for working with SQLAlchemy queries and eventsSQLAlchemy DocumentationContentsRequirementsInstallationUsageSQLAlchemy EnhancementsMySQL DiffMySQL Version ManagerBug trackerContributingContributorsLicenseRequirementspython >= 2.6mysql-diff == 0.3 (built into the base Docker image)InstallationCT Core DBis hosted on our internalPyPi repository. It should be installed using pip:pip install ct-core-dbUsageMost of the functionality exposed by this library is made available through the SQLAlchemyct_core_db.dbinstance or via thedbFlask commands inct-core-api.SQLAlchemy Enhancementsct_core_db.lib.db_utils– Various utilities for debugging and logging SQLAlchemy queries and eventsct_core_db.lib.sqla– Improved signalling session that avoids PK collisions, base model, and model mixinsct_core_db.lib.sqla_types– Custom SQLAlchemy column data typesMySQL DiffUse themysql_diff.MySQLDiffCommandto produce a database migration script based on the differences between two
MySQL database schemas:from ct_core_db.lib import mysql_diff

mysql_diff_cmd = mysql_diff.MySQLDiffCommand()
diff_output = mysql_diff_cmd('jdbc_db_url_a', 'jdbc_db_url_b')MySQL Version ManagerUse themysql_version.MySQLVersionManagerclass to create, diff, and upgrade your MySQL database schemas:from ct_core_db.lib import mysql_diff

mysql_version_manager = mysql_version.MySQLVersionManager(engine, mysql_diff_cmd)
mysql_version_manager.init_db()
mysql_version_manager.create_db()
mysql_version_manager.diff_db()  # Invokes `mysql_diff_command`
mysql_version_manager.upgrade_db()Bug trackerIf you have any suggestions, bug reports or
annoyances please report them to the issue tracker
athttps://github.com/catalant/ct-core-db/issuesContributingDevelopment of ct-core-db happens at github:https://github.com/catalant/ct-core-dbContributorsjcrafford(Justin Crafford)LicenseLicensed under aMIT license.
Package: ctd
python-ctdTools to load hydrographic data as pandas DataFrame with some handy methods for
data pre-processing and analysisThis module can loadSeaBird CTD (CNV),Sippican XBT (EDF),
andFalmouth CTD (ASCII)formats.Quick introYou can install the CTD package withcondainstallctd--channelconda-forgeorpipinstallctdand then,frompathlibimportPathimportctdpath=Path('tests','data','CTD')fname=path.joinpath('g01l06s01.cnv.gz')down,up=ctd.from_cnv(fname).split()ax=down['t090C'].plot_cast()We can dobetter:temperature=down['t090C']fig,ax=plt.subplots(figsize=(5.5,6))temperature.plot_cast(ax=ax)temperature.remove_above_water()\.despike()\.lp_filter()\.press_check()\.interpolate(method='index',limit_direction='both',limit_area='inside')\.bindata(delta=1,method='interpolate')\.smooth(window_len=21,window='hanning')\.plot_cast(ax=ax)ax.set_ylabel('Pressure (dbar)')ax.set_xlabel('Temperature (°C)')Try it out on mybinder
Package: ctdcal
ctdcal projectThe ctdcal project is a library primarily designed to process data from CTD casts and calibrate
them against Niskin bottle samples.In the future, parts of the ctdcal library will be split off into additional packages,
such as an "ocean sensors" package with Python implementations of conversion routines
for in-situ sensors used for ocean measurement.Installationctdcal can be installed using pip:$ pip install ctdcalCLI usageInitialize data foldersInitialize default/data/folders by running:$ ctdcal init(Future versions of ctdcal are planned have more robust init options/flags/etc.)Import and process dataTo process data, copy over raw.hexand.xmlconfiles into/data/raw/and reference data to their appropriate folder (oxygen,reft,salt).Users can process their data with individual ctdcal functions or try:$ ctdcal process [--group ODF]to process using ODF procedures.Package usageExplore user settingsMost ctdcal functions get settings fromuser_settings.yamland subsequentlyconfig.py. Call the configuration loader to explore default settings:fromctdcalimportget_ctdcal_configcfg=get_ctdcal_config()# directories for I/O purposesprint(cfg.dirs)print(cfg.fig_dirs)# experiment-specific settings (e.g., expocode, CTD serial number) from user_settings.yamlprint(cfg.settings)# dictionary mapping of short/long column namesprint(cfg.columns)As ctdcal continues to be developed, more robusttutorialswill be added toour documentation.LICENSINGBSD 3-clause