Saravanan666/pypi-org huggingface dataset:
Package: chi-mailer
Chi_MailerUSAGE:Chi_Mailer is a  python script to for mass mailing. With it you can forget the
hastle of having to mail messages an email after an email. You can just write
your message one and the email we'll automate the rest at your comfort.
All you have to do is geek with chi_mailer, take a cup of coffee all whatever you
use, and the rest we'll be done for you.New Features!Ability to send bulk/mass emailsAbilty to input your server's credential at script startup so that you don't
have to stress yourself with script alteration.Ability to hide your server credential at input to avoid bad spectator eyes from
seeing your password.Ability to use the script with or with no python knowledge.Installationchi_mailer at the moments requirespython3+at the momentlinux users:Run the following command in the project's root folder via terminal(.i.e after
extracting chi_mailer, open the chi_mailer folder and right-click to open the
terminal, that way you'll be in the projects root folder and type python Qi.py)Method 2:
Change directory using the 'cd' command to enter into the project's folder
$ cd chi_mailer         (To enter into the project's directory)
$ ls                    (To view the content in the directory)
$ python3 Qi.pywindows users:Method 1
After extracting the chi_mailer download, double click to enter to the project's
root folder, and hold shift and right click to open powershell or cmd(command prompt)Method 2:
Via startbar type or navigate to command prompt and run as an adminstrator
Now inside the command prompt lets navigate to the project's folder

> cd downloads
> ls                    (To view the content in the directory)
> cd chi_mailer         (Change directory to ch_mailer folder)
> python3 Qi.py         (run our python script)The message.txt is where your message should be put as a simple and fast way of calling our message  which uses a concept known as templating string within our document from the script and avoiding code alteration.
The mass mails where the message will be sent to should be put in contacts.txt    document following the sample.txt format.DevelopmentThe project is open for contribution.TodosConvert all user input mails to lowercase. (Humans are prone to errors/typos)Time interval to enable code to send mails and repeat again after a certain timeCode Compatibility to enable all users use the script.LicenseMITNB:---> The server mail needs to be given privilege for your script to act as a stand alone,
visit(https://myaccount.google.com/security) and enable less secure apps to give your
script power. Mail server is set to use gmail at default.**Stay Safe and Enjoy Your new free Mail Server!**
Package: chimeera
Your project description goes hereDocumentationThe full documentation is athttps://chimeera.readthedocs.org.QuickstartInstall chimeera:pip install chimeeraThen use it in a project:import chimeeraFeaturesTODORunning TestsDoes the code actually work?source <YOURVIRTUALENV>/bin/activate
(myenv) $ pip install -r requirements_test.txt
(myenv) $ python runtests.pyCreditsTools used in rendering this package:Cookiecuttercookiecutter-djangopackageHistory0.1.0 (2016-06-25)First release on PyPI.
Package: chime-frb-api
CHIME/FRB APITestingCoverageReleaseStylechime-frb-apiis a python library to access CHIME/FRB backend. This library enables you interact with resources such as databases, event headers, calibration products, cluster jobs etc.Check out thedocumentationfor more details.InstallationThe latest stable version is available onPyPI.
To installchime-frb-apisimply run,pipinstall--upgradechime-frb-apiTo addchime-frb-apito your project,poetryaddchime-frb-apiDocumentationFor further reading, please refer to thedocumentation.
Package: chime-frb-constants
CHIME/FRB ConstantsA pure-python, lightweight and zero dependency package to access constants used in the CHIME/FRB software projects.Installationpip install chime-frb-constantsOptionalIfscipyis installed in the python environment,frb-constantswill also expose the physical constants, otherwise it is set toNoneimportchime_frb_constantsasconstantsconstants.phy_constUsageimportchime_frb_constantsasconstantsprint(constants.K_DM)4149.377593360996print(constants.phys_const.speed_of_light)299792458.0Changelog2020.07UpdatedCHANNEL_BANDWIDTH_MHZFixed errors withFREQAdded optional physical constants fromscipy2020.06.3Fixed error withCHANNEL_BANDWIDTH_MHZChange toSAMPLING_TIME_MSNew constantSAMPLING_TIME_S2020.06.2Added constantsFREQandFREQ_FREQ2020.06Release onPYPIAll constants are now uppercaseAll physical constants fromscipyare not availaible anymore under constants.
Package: chimera-gw
CHIMERACHIMERA(Combined Hierarchical Inference Model for Electromagnetic and gRavitational-wave Analysis) is a flexible Python code to analyze standard sirens with galaxy catalogs, allowing for a joint fitting of the cosmological and astrophysical population parameters within a Hierarchical Bayesian Inference framework.The code is designed to be accurate for different scenarios, encompassing bright, dark, and spectral sirens methods, and computationally efficient in view of next-generation GW observatories and galaxy surveys. It uses the LAX-backend implementation and Just In Time (JIT) computation capabilities of JAX.InstallationThe code can be quikly installed fromPypi:pip install chimera-gwFor more flexibility, clone the source repository into your working folder and install it locally:git clone https://github.com/CosmoStatGW/CHIMERA
cd CHIMERA/
pip install -e .To test the installation, run the following command:python -c "import CHIMERA; print(CHIMERA.__version__)"DocumentationThe full documentation is provided atchimera-gw.readthedocs.ioCitationIf you find this code useful in your research, please cite the following paper (ADS,arXiv,INSPIRE):@ARTICLE{2023arXiv231205302B,
    author = {{Borghi}, Nicola and {Mancarella}, Michele and {Moresco}, Michele and et al.},
        title = "{Cosmology and Astrophysics with Standard Sirens and Galaxy Catalogs in View of Future Gravitational Wave Observations}",
    journal = {arXiv e-prints},
    keywords = {Astrophysics - Cosmology and Nongalactic Astrophysics, Astrophysics - Astrophysics of Galaxies, General Relativity and Quantum Cosmology},
        year = 2023,
        month = dec,
        eid = {arXiv:2312.05302},
        pages = {arXiv:2312.05302},
        doi = {10.48550/arXiv.2312.05302},
archivePrefix = {arXiv},
    eprint = {2312.05302},
primaryClass = {astro-ph.CO},
    adsurl = {https://ui.adsabs.harvard.edu/abs/2023arXiv231205302B},
    adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
Package: chimerapy
DocsChimeraPy is a distributed computing framework for multimodal data dollection, processing, and feedback. It's a real-time streaming tool that leverages from a distributed cluster to empower AI-driven applications.Collectyour data in real-time from any computer and time aligned it to the rest of your data streams.Processdata as soon as it comes, providing a service to your users.Archiveyour outputs and later retrieve them in a single main data archive for later careful post-hoc analysis.Monitorthe executing of your distributed cluster, view live outputs, and verify that you collected clean data.InstallationYou can install the package with the following command.pip install chimerapyAdditionally, you can install the package through GitHub instead.git clone https://github.com/oele-isis-vanderbilt/ChimeraPy
cd ChimeraPy
pip install .ContributingContributions are welcomed! OurDeveloper Documentationshould provide more details in how ChimeraPy works and what is in current development.LicenseChimeraPy uses the GNU GENERAL PUBLIC LICENSE, as found inLICENSEfile.
Package: chimerapy-engine
DocsThis repo houses the networking engine forChimeraPy, the scientific distributed computing framework for multimodal data dollection, processing, and feedback.InstallationYou can install the package with the following command.pip install chimerapyAdditionally, you can install the package through GitHub instead.git clone https://github.com/ChimeraPy/ChimeraPy-Engine
cd ChimeraPy-Engine
pip install .ContributingContributions are welcomed! OurDeveloper Documentationshould provide more details in how ChimeraPy's engine works and what is in current development.LicenseChimeraPy and ChimeraPy-Engine uses the GNU GENERAL PUBLIC LICENSE, as found inLICENSEfile.Funding InfoThis project is supported by theNational Science Foundationunder AI Institute  Grant No.DRL-2112635.
Package: chimerapy-orchestrator
Reusable Nodes and Orchestration Scheme/ Dashboard Application for ChimeraPy with JSON configuration.ChimeraPy is a Scientific, Distributed Computing Framework for Real-time Multimodal Data Retrieval and Processing. This package provides reusable nodes and orchestration scheme (CLI)/ and web dashboard application(via REST API) for ChimeraPy with JSON configuration.InstallationPackage is available onPyPI, install withpip:$pipinstallchimerapy-orchestratorUsage for Orchestrator CLIInstallation providescp-orchestratorcommand:$cp-orchestrator--help
usage:TheCPorchestrator[-h]{orchestrate,orchestrate-worker,list-remote-workers,server}...

options:-h,--helpshowthishelpmessageandexitsubcommands:validsubcommands{orchestrate,orchestrate-worker,list-remote-workers,server}orchestrateOrchestratethepipelineorchestrate-workerOrchestrateaworkerlist-remote-workersListtheremoteworkersserverStarttheserverSpecific subcommands also have their own help messages, and can be usedcp-orchestrator <subcommand> --help.Orchestrator CLI ExampleIn theconfigsdirectory, there are few configuration examples for simpleChimeraPypipelines.The command below will run a pipeline that uses the webcamera and showwindow nodes and runs it in a local worker:$cp-orchestratororchestrate--configconfigs/local_camera.jsonThe commands below will run a pipeline that uses the webcamera node and runs it in a remote worker:$cp-orchestratororchestrate--configconfigs/local_camera_remote_worker.jsonIn a separate terminal, run the remote worker:$cp-orchestratororchestrate-worker--configconfigs/local_camera_remote_worker.json--worker-idworker1DashboardThe dashboard application is still in early stages of development and can't be used directly yet. However, it can be run in development mode.
To run the dashboard, run the backend server first:$cp-orchestratorserver--server-port8000Then, in a separate terminal, run the dashboard:$cddashboard
$npminstall
$npmrundevFinally, open a browser and navigate tohttp://localhost:5173for the dashboard.ContributingContributions are welcomed! OurDeveloper Documentationshould provide more details in how ChimeraPy works and what is in current development.LicenseChimeraPyandChimeraPy/Orchestratoruses the GNU GENERAL PUBLIC LICENSE, as found inLICENSEfile.Funding InfoThis project is supported by theNational Science Foundationunder AI Institute  Grant No.DRL-2112635.
Package: chimera-python
Chimera is a package to control astronomical observatories aiming the
creation of remote and even autonomous observatories with just a few
clicks. Using Chimera you can easily control telescopes, CCD cameras,
focusers and domes in a very integrated way.DistributedFully distributed system. You can use different machines to
control each instrument and everything will looks like just one.PowerfulVery powerful autonomous mode. Give a target and exposure parameters
and Chimera does the rest.Web interfaceWeb interface to schedule and monitor observations (in development).Hardware supportSupport for most common off-the-shelf components. Seesupported
devices.Very easy to add support for new instruments (it’s Python code!).FlexibleChimera can be used in a very integrated mode but also in standalone
mode to control just one instrument.FreeIt’s free (as infree beer) and written in a very modern
language. Python!.Getting startTo try out Chimera, follow the installation instructions and make sure
that you have at least onesupported devices.The easiest way to install Chimera is to useeasy_install:sudo easy_install chimera-python… and that’s it! All dependencies are automagically installed.You can also download the sources atChimera Development pageand try to install itby hands.Help and DevelopmentYou can help Chimera development, we are always looking for
contributors. If you don’t write code, no problem! You can write
documentation, help with this site, marketing. Everyone can help!See ourDevelopmentpage for
more information, to report a bug or just follow Chimera’s development
closely.Supported DevicesTelescopesMeadebased LX-200 (Meade, Losmandy).Paramount MEusing TheSky COM+ interfaces.CCD CamerasSBIGUSB cameras.FocusersOPTECNGF-SDomesCOTE/LNA Dome (LNAspecific).In DevelopmentCCD CamerasApogeeUSB/Ethernet cameras.NoteIf you need support for any device which Chimera’s doesn’t
support, call us and we can try to develop it or help you to do it.LicenseChimera is Free/Open Software licensed byGPL v2or later (at your choice).AuthorsChimera is mainly developed by Paulo Henrique Silva
<ph.silva@gmail.com> atUniversidade Federal de Santa Catarinain collaboration with his advisor Antonio
Kanaan.Chimera is sponsored byLaboratorio Nacional de Astrofisicathrough aCNPqgrant.
Package: chimera-utils
chimera_utilsIntroductionThis is a suite of tools for processing chimeric reads generated at a STAR alignment step (Chimeric.out.sam files).DependencyPythonpysam,annot_utils,fusionfusionSoftwarehtslib,bedtoolsInstallpip install chimera_utilsAlternatively you can download from the source code:wget https://github.com/friend1ws/chimera_utils/archive/v0.5.0.tar.gz
tar zxvf v0.6.0.tar.gz
cd chimera_utils-0.6.0
python setup.py build installFor the last command, you may need to add --user if using a shared computing cluster.CommandscountCount supporting read pairs for each chimera junctionchimera_utils count [-h] [--abnormal_insert_size ABNORMAL_INSERT_SIZE]
                          [--min_major_clipping_size MIN_MAJOR_CLIPPING_SIZE]
                          [--min_read_pair_num MIN_READ_PAIR_NUM]
                          [--min_cover_size MIN_COVER_SIZE]
                          [--anchor_size_thres ANCHOR_SIZE_THRES]
                          [--min_chimeric_size MIN_CHIMERIC_SIZE] [--debug]
                          Chimeric.out.sam output_filemerge_controlMerge chimeric junction cout file (generated bycountcommand) of control data (typically) for later filteringchimera_utils merge_control [-h] chimeric_count_list.txt output_fileassociateAssociate chimeric junctions with the output of GenomonSVchimera_utils associate [-h] [--margin MARGIN]
                               [--sv_margin_major SV_MARGIN_MAJOR]
                               [--sv_margin_minor SV_MARGIN_MINOR]
                               [--genome_id {hg19,hg38,mm10}] [--grc]
                               [--debug]
                               chimera.txt genomonSV.result.txt output.txt
Package: chimere
Chimère is a cartographic mashup using OpenStreetMap as a default map layer.
This software aims to create online collaborative and thematic maps. Content
(multimedia, text) are associated to basic geographics items (Point Of Interest,
routes). Add on the map are open to everybody with no authentification but are
moderated by a team in charge of the map.Features:Display (by default) of the mapnik OpenStreetMap layer.Display on the map of POIs (with markers) and routes (with colored
polylines).Thematic choices of items to display (POIs and routes).Filter themes in regard to currently available items.Display of the detail of a POI (name, description, pictures, multimedia
files).Add of a cartographic item (POI, route) on the map by an user without
authentication (the item is only available after moderation).Admin interface for moderation and configuration.Cut a Chimère by “areas”. Each “area” can have specific themes, a new default
center, welcome message, bounding box, allow of restriction to a bounding
box, activation of dynamic themes, available themes, themes checked by
default.Import and export of data. Available formats are: ShapeFile, KML, GeoRSS
(import only), CSV and OSM.Configuration of map layers in administration interface. By default these
cartographic items are available: OSM Mapnik, MapQuest, OSM Transport,
Cyclemap.Full documentation is available onRead the docs.External libsTo be fully functional, this package is provided with external libs:OpenLayers- 2006-2012 OpenLayers Contributors - 2-clause BSDOsmApi- 2009-2010 Étienne Chové - GPL v3.prettyPhoto- 2012 Stephane Caron - GPL v2.jMediaelement- 2010 Alexander Farkas - GPL v2 and MIT.bsmSelect- 2010 Victor Berchet - GPL v2 and MIT.
Package: chimney
Chimney=======You may need a coffeescript compile, a browserify transform and thenwant to run uglify to minimize the source for production javascriptfiles. Or a maybe a SASS compile and minimization.Chimney is a simple build system primarily intended for webassets. There are many build systems and most asset compilers arecapable of watching for changes, but it becomes difficult to managewhen more steps are added to the pipeline.Compilers---------At each step of the process, there is some input, some output and atransformation process. Chimney simply calls these "compilers" forsimplicity, but they can be any kind of Python code.To declare a new type of compiler, define a subclass of ``Compiler``:```pythonfrom chimney.compilers import Compilerclass coffee(Compiler):def run(self):# perform compile```Targets-------Targets are the goal of compilation. This might be a final executableor an combined javascript file for a page.Here is an example of a javascript target that needs to be built fromseveral coffee files (this is using the above compiler):```pythonimport chimneychimney.make(coffee('smoke.js', ['wood.coffee', 'fire.coffee']),)```This will compile each of the .coffee dependencies to their .js outputforms using the ``coffee`` compiler defined above, then combine thosefiles into ``smoke.js``.Next, there should be a step to minify ``smoke.js`` if needed. That'seasy with chimney, simply add another task to the above definition:```pythonchimney.make(coffee('smoke.js', ['wood.coffee', 'fire.coffee']),uglify('smoke.min.js', 'smoke.js'),)```Chimney already provides compilers for the most popular webassets. Others can easily be added to your script by extending theCompiler class.Watching for changes--------------------To automatically re-execute tasks when their dependencies change,the function ``chimney.watch`` will first execute all tasks normallybut then it will watch for any filesystem changes.To get this functionality, the api is slightly different. Instead ofexpecting a list of tasks, the function ``chimney.watch`` requiresa function. This is called when new files are added so the dependenciescan be recalculated. For example:```pythondef create_tasks():return [coffee('smoke.js', ['wood.coffee', 'fire.coffee']),uglify('smoke.min.js', 'smoke.js'),]chimney.watch(create_tasks)```Whenever the coffee files are changed, ``smoke.js`` will be re-createdusing the ``coffee`` compiler. Then ``smoke.min.js`` will be created, too.When new files are added, the function ``create_tasks`` will be re-executedto build a new set of tasks. This is useful for dynamically buildingtasks.By default, the reload will start chimney on all new files, which maybe too often. You can provide a list of (shell) patterns to matchto limit reloading:```pythondef create_tasks():return [coffee('smoke.js', ['wood.coffee', 'fire.coffee']),uglify('smoke.min.js', 'smoke.js'),]chimney.watch(create_tasks, reload_patterns=['*.coffee'])```
Package: chimoney-py
PyChimoneypychimoney is a python wrapper forChimoney- Account
- Info
- Payout
- Mobile Money 
- Wallet
- Sub-Account
- RedeemGetting StartedRegister withChimoneyRequest for API KEY from supportset Your "CHIMONEY_AUTH_KEY" environment variableInstalling- pip install chimoney-pyOR- git clone "the repo"
- cd pychimoney
- python setup.py install or
- pip3 install .UsageImporting the packagefromchimoneyimportChimoneyCreating an instance of the Chimoney classchimoney=Chimoney.set_api_key("API-KEY")Full ExamplefrompychimoneyimportChimoneyimportos# Initialize Chimoneychimoney=Chimoney.set_api_key("CHIMONEY_AUTH_KEY")Using the Account APIchimoney.account.required_function(params)TODOAdd all EndpointsWrite Unit TestsPackage the LibraryAdd to PipAdd Pytest and Covrage for TestDocumentation
Package: chimopy
.chimopyThis is a wrapper providing convenient access to the Chimoney API for applications written in Python.It has been tested with Python 3.xxSetup and InstallationpipinstallchimopyYou can also clone or download the library package and install it using setuptools:gitclonehttps://github.com/morehwachege/chimopy.gitcdchimopy
pythonsetup.pyinstallUsagefromchimopy.<API>import<APIClass>APIThe following APIs are supported:AccountInfoMobile-MoneyPayment, all except airtimeRedeemSub AccountWalletAPI ClassThe following are the corresponding API classes:AccountInfoTransactionPayRedeemSubAccountWalletDependenciesNone at the momentHow to Install from SourceBuilding from Source for Developersgitclonehttps://github.com/morehwachege/chymopy.gitcdchimopy
pythonsetupybdist_wheel
pythonsetupyinstallContributingSee the Contributing FileSee the Pull Request FileSupportLICENCEMIT
Package: chimpflow
chimpflowService which polls the database for subwell images which need to have the chimp detector run on them.Uses xchembku for database interaction.For documentation see:https://diamondlightsource.github.io/chimpflowModel file for xchem-chimpThe model file is saved in::https://gitlab.diamond.ac.uk/xchem/xchem-chimp-modelsThis file is too large for github.For GitHub pytest to find the file in its CI/CD Actions, this file has been uploaded to zenodo:https://zenodo.org/record/7810708/2022-12-07_CHiMP_Mask_R_CNN_XChem_50eph_VMXi_finetune_DICT_NZ.pytorchThe tests/conftest.py fetches this file automatically.