Saravanan666/pypi-org huggingface dataset:
Package: cordwainer
A better CSV libraryFeaturesLets you program in both Python 2 and Python 3 as if you had the
Python 3 CSV module.Under Python 2, provides a Python 3 compatiblecsvmodule.Under Python 3, passes through transparently.Lets your CSV files be encoded any way you want.Python 3 compatibilityimport cordwainer.csv as csvought to be equivalent to importing the
Python 3csvmodule, whether running with Python 2 or 3. See thePython 3 csv module documentationCSV file encodingThe Python 2 csv module expects file handles passed to it to
return data encoded in ASCII or UTF-8, and writes it to files
the same way.The Python 3 csv module expects handles passed to it to return text
data, already decoded, and writes un-encoded text data to them. It’s
your responsiblity to arrange for conversion when you open the file,
or pipe your stream through some kind of conversion.Using Cordwainer, you can just pass an extraencodingparameter
to say that your stream is providing or expecting binary data
with the specified encoding, and Cordwainer will take care of
all necessary conversions.Ifencodingis omitted orNone, Cordwainer assumes the
provided stream will provide or expect un-encoded text data, just
like Python 3’s csv module.Misc. Usage NotesTheencodingparameter isonlyapplied for reading from and
writing to streams.String arguments should always be passed to the API
as characters, and results are always characters.E.g.:Pass fieldnames to DictWriter as charactersPass data in rows to writerow() as charactersnext() returns rows in charactersIntended (eventually) featuresOptional header rowValidate expected fields, types (probably specify a Django form
to do the validation)Verbose error handling - say what the problem was on what line,
for every line that has an errorOptionally stop processing after N errorsOptionally import the lines that are valid while skipping invalid
onesOptionally do the whole thing in one transactionOptionally ignore any extra columnsOptionally save uploaded file and then process it in a background
task (to not delay the HTTP request)For Excel, be flexible in deciding what sheet to import - or even
import from multiple sheets from one upload
Package: cord-workflow-controller-client
A CORD Workflow Controller Client Library.
This library allows users to communicate to CORD Workflow Controller.
There are three classes provided, Manager, Probe and WorkflwoRun.ManagerThis class is used to act as a workflow manager.
Workflow Managers manageworkflow registrationand handlekickstartevents.ProbeThis class is used to act as a probe.
Probes emit events to CORD Workflow Controller.WorkflowRunThis class is used to act as a workflow run.
Workflow Runs are used by workflow instances to receive events emitted by Probes.
Package: core-algorithms
core-algorithmsThis project/library contains common algorithms...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage
Package: coreali
coreali - Convenient Register Access LibraryGenerates Python code from a register model. This python code can the be used to access the registers of an FPGA, a MCU or another device which has a register map.InstallationCoreali can be installed with pip by executing the following commandpip install corealiHow to useThe typical use case for coreali is:Make a register description of your system insystemRDLor any other supported format (ipxact) of thesystemrdl-compilerCompile the register description with thesystemrdl-compilerGenerate the hierarchical register model class and objects with thecoreali.RegisterModelAccess the registers of your FPGA device withcoreali.registerioQuickstart - Logger exampleCreate a register description of your system or modulemem log_mem {
    mementries = 64;
    memwidth = 8;
};

addrmap logger { 
	reg  {	
		desc = "Control register";
		field {sw = rw; hw = r;} ENABLE;
		field {sw = rw; hw = r;} TRIGGERED;
	} Ctrl;
	reg  {	
		desc = "Trigger configuration for channel 0 and 1";
		field {sw = rw; hw = r;} SW_TRIG;
		field {sw = rw; hw = r;} LEVEL[8];
	} Trig[2];
  	external log_mem LogMem[2];
};Import dependencies and compile register model with systemrdl-compilerimportsysfromsystemrdlimportRDLCompilerimportcorealiimportnumpyasnprdlc=RDLCompiler()rdlc.compile_file("../systemrdl/logger.rdl")root=rdlc.elaborate()Create the register model objectrio=coreali.registerio.RegIoNoHW(np.zeros([256],np.uint8()))logger=coreali.RegisterModel(root,rio)In this step the rio register input/output obkect is created. This object handles the low level access. The RegIoNoHW class allows to access virtual registers without having a hardware at hand. The XXXXX example shows how to create your own RegIo class to access your own hardware.TODOUse the generated register modellogger.Ctrl.read()logger.LogMem.write(0,[1,2,3])logger.LogMem.read()logger.LogMem[1].write(0,[11,12,13])print(logger)The registers can now be read and written by hierarchically accessing them. With code completion of your python IDE the registers can be accessed conveniently.When using the print function on a register, register node or address map all registers and field will be readout and printed as a string.The full source code of this example can be found inexamples/quickstart/
Package: coreapidocs
coreapidocs [![travis][travis-image]][travis-url] [![pypi][pypi-image]][pypi-url]===Document APIs with CoreAPI.### Prerequisites- Python (2.7, 3.3, 3.4, 3.5)- Core API ([Read More](http://www.coreapi.org/))### InstallationYou can install `coreapidocs` through pypi.pip install coreapidocs### UsageYou will have to pass a `.json` document to initialize the docs.```pythonfrom coreapidocs.docs import Docstry:schema = open(filename, 'rb').read()docs = Docs(schema)except (IOError, OSError):abort(400, {"msg": "No such file or directory - %s" % filename})```Then you can simply pass the `docs` variable to your template (ie. Flask):```pythonreturn render_template('home.html', docs=docs.get_docs())```For more information view the source of [example.py](coreapidocs/example.py).### DevelopmentCreate the virtualenv and install the requirements.virtualenv envsource env/bin/activatepip install -r requirements.txtYou will need to pass an argument ie. `document.json`.python coreapidocs/example.py document.json# Then go to: http://127.0.0.1:5000/### UsageBelow you can find an example Flask application. Using `jinja2` you can pass the `coreapidocs` template to your view.```pythonimport sysimport jinja2from flask import Flask, abort, render_templatefrom coreapidocs.docs import Docsapp = Flask(__name__)@app.route('/')def docs():"""Generate the coreapidocs and serve them to roor.Accepts one parameter with a filename (ie. document.json)"""if len(sys.argv) != 2:abort(400, {"msg": "Missing file parameter ie. document.json"})filename = sys.argv[-1]try:schema = open(filename, 'rb').read()docs = Docs(schema)except (IOError, OSError):abort(400, {"msg": "No such file or directory - %s" % filename})templates_loader = jinja2.PackageLoader('coreapidocs', 'templates')template_env = jinja2.Environment(loader=templates_loader)template = template_env.get_template('docs.html')# FIXME: Figure out how to pas static filesreturn render_template(template, docs=docs.get_docs())@app.route('/<path:path>')def static_proxy(path):"""Serve static files."send_static_file" will guess the correct MIME type"""return app.send_static_file(path)if __name__ == '__main__':app.debug = Trueapp.run()```### TestsIn order to run the tests you will have to run:python runtests.py[travis-image]: https://travis-ci.org/ekonstantinidis/coreapidocs.svg[travis-url]: https://travis-ci.org/ekonstantinidis/coreapidocs[pypi-image]: https://badge.fury.io/py/coreapidocs.svg[pypi-url]: https://pypi.python.org/pypi/coreapidocs/
Package: core-aws
core-awsThis project/library contains common elements related to AWS services...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage
Package: core-aws-cdk
core-aws-cdkThis project contains the commons elements to create infrastructure
in AWS using AWS CDK...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage
Package: corebases
CorebasesFull power ofasyncpgwith user friendly api ofsqlalchemy.coreCorebases - isasyncadapter forSqlalchemy.Core.
Interface and code based onencode/databases, but has bitdifference. Now supported onlyasycnpgdriver (but It's possible to extend)Current status -ExperimentalReason for create forkhttps://github.com/encode/databases/issues/403#issue-1016133277Install>pipinstallcorebasesUsage# Create a database instance, and connect to it.fromcorebasesimportdatabasedatabase=database('postgres://user:pass@localhost:5432')awaitdatabase.connect()# Insert some data.query="INSERT INTO HighScores(name, score) VALUES (:name, :score)"value={"name":"Daisy","score":92}withdatabase.transaction()asdb:awaitdb.execute(query=query,value=value)# Run a database query.query="SELECT * FROM HighScores"rows=awaitdatabase.fetch_all(query=query)print('High Scores:',rows)awaitdatabase.disconnect()Difference between encode/databasesPrincipal is a bit of difference in interface on transactions:encode/database:withdatabase.transaction():awaitdatabase.execute(query=query,value=value)corebases:withdatabase.transaction()asdb:awaitdb.execute(query=query,value=value)Also,corebasesdoesn't support methods:feach_valexecute_manyBut we can add in the future.
Package: corebmtk
corebmtkA module to allowBMTKto function withCore Neuronbefore official support.Currently, BMTK usesh.runandextracellularNEURON mechanisms, which are both incompatible with CoreNeuron.corebmtkusespc.psolveand takes an alternate approach to recording and storing output. The goal of this project
was to maintain all of BMTK's functionality while allowing for the use of CoreNeuron.
Recording modules remove thestepphase and integrate intoinitializeandfinalizeto be compatilbe withpc.psolve.Installationpip install --upgrade corebmtkUsageIn yourrun_network.pyBMTKscript replace your BioSimulator with a CoreBioSimulator.import corebmtk

# sim = bionet.BioSimulator.from_config(conf, network=graph)
sim = corebmtk.CoreBioSimulator.from_config(conf, network=graph)When using MPI you'll have to replace your config as well. This wrapper prevents loading of mechanisms prior to running withx86_64/special.# conf = bionet.Config.from_json(config_file, validate=True)
conf = corebmtk.Config.from_json(config_file, validate=True)LimitationsSome recoring mechanisms are not yet implemented. See run output for more info.Implemented recording modules:reports.SpikesReportnetcon_reportreports.MembraneReport (report.params['sections'] == 'soma')reports.ECPReportModules NOT implementedmods.MembraneReport(general)reports.ClampReportsave_synapsesTroubleshootingWhen using ECP recording:CoreNEURON cannot simulate a model that contains the extracellular mechanismChange yourecp reportto use"module": "ecp"instead of"module": "extracellular""ecp": {
      "cells": "all",
      "variable_name": "v",
      "module": "ecp",
      "electrode_positions": "./components/recXelectrodes/linear_electrode.csv",
      "file_name": "ecp.h5",
      "electrode_channels": "all"
    }AcknowledgmentsThanks@gregglickertfor kicking this project off.BMTK
Package: corebodytemp
Welcome to corebodytemp 👋Python BLE API for interacting with CoreBodyTemp Sensors🏠HomepageInstallpipinstallcorebodytempAuthor👤Stavros AvramidisGithub:@purpl3F0xShow your supportGive a ⭐️ if this project helped you!📝 LicenseCopyright © 2022Stavros Avramidis.This project isMITlicensed.
Package: corebytecms-forms
FeaturesCreate a cms page where you can setup form fields, a captcha and submit button.Works in python3.Set the apphook to ‘Forms’ and then the redirect works.Create a ‘thank you’ page where you can redirect to.Forms and all fields are saved in the database.When set thesend mail optionit sends a mail with all the fields to the specified receivers.In the admin, can view every form submission with the fields.In the admin, export is possible to .csv.InstallationRunpip installgit+https://github.com/svandeneertwegh/corebytecms-forms.UpdateINSTALLED_APPSwithINSTALLED_APPS = [
    ...
    'cms_forms',
    'cms_forms.contrib.email_notifications',
    'captcha',
]Creating a FormYou can create forms in the admin interface now. Search for the labelForms.Create a CMS page and install theFormsapp there (chooseFormsfrom theAdvanced Settings->Applicationdropdown).Now redeploy/restart the site again.The above CMS site has become a forms POST landing page - a place where submission errors get displayed if there are any.Available Plug-insFormplugin lets you embed certain forms on a CMS page.Fieldsetgroups fields.Text Fieldrenders text input.Text Area Fieldrenders text input.Yes/No Fieldrenders checkbox.Select Fieldrenders single select input.Date Fieldrenders date input.Multiple Select Fieldrenders multiple checkboxes.File fieldrenders a file upload input.Image fieldsame asfile fieldbut validates that the uploaded file is an image.
Package: core-cache-manager-app
Core Cache Manager AppCache management feature for the curator core project.Configuration1. Add “core_cache_manager_app” to your INSTALLED_APPS setting like thisINSTALLED_APPS=[..."core_cache_manager_app",]2. Include the core_cache_manager_app URLconf in your project urls.py like thisurl(r'^',include("core_cache_manager_app.urls")),
Package: core-cdc
core-cdc (CDC a.k.a Change Data Capture)It provides the core mechanism and required resources to
implement "Change Data Capture" services...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage
Package: core-ciphers
core-ciphersThis project/library contains common elements related to ciphers...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage
Package: corecomb
Corecomb: create a XMFA file from Panaroo core gene alignments to detect recombination in core-genome using ClonalFrameML.InstallationpipinstallcorecombQuick startIf you are in Panaroo output directory, just run:corerecombGet help$corecomb--helpUsage:corecomb[OPTIONS]CreateXMFAfilefromClonalFrameMLinputfromPanaroocore-genomegenealignments

╭─Options───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│--gene_al_dirTEXTPathtodirectorycontainingcore-genomegenealignments[default:core_gene_alignments]│
│--pan_faTEXTPathtoPanaroopan_genome_reference.fa[default:pan_genome_reference.fa]│
│--extensionTEXTFileextensionofcore-genomegenealignments[default:fas]│
│--outfileTEXTPathtooutputXMFAfile[default:corecomb.xmfa]│
│--helpShowthismessageandexit.│
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯WhyIn theory, using the indivudal core-gene multiple sequence alignments from thecore_gene_alignmentsdirectory of Panaroo, one could just run asedcommand to concatenate these in aXMFA file.sed-e'$s/$/\n=/'-s../tests/data/aligned_gene_sequences_raw/*.fas>core_gene_alignment.xmfaHowever, this approach suffers from 3 different issues:Sequence names need to be cleanedAmbiguous nonNIUPAC characters need to be taken care of (CFML only acceptsA,T,G,C,N,-)Genomes with missing genes will cause CFML to crash (core-genome defined at less 100%)CoRecomb addresses all 3 of these issues. Additionally, CoRecomb uses the order of the genesdefined in thepan_genome_reference.fato re-order the genes in the XMFA file (which will be kept by CFML outputcore_gene_test_cfml.filtered.fasta).Test it for yourselfpoetryrunpytest-vvTest data can be found heretests/datacorecomb\--gene_al_dirtests/data/aligned_gene_sequences_raw\--pan_fatests/data/pan_genome_reference.fa\--extensionfas\--outfilecorecomb.xmfaUse the XMFA with ClonalFrameMLClonalFrameML\input_tree.nwk\corecomb.xmfa\cfml_output_basename\-xmfa_filetrue\-show_progresstrue\-output_filteredtrue
Package: core-common
CORE COMMONIt is a module of the Research CORE ERM which implements the most basic models
required by the CORE platform:CitizenshipCityCountryCurrencyInstitutionNationalityInstallationpipinstallcore-commonEnterprise Resources Management- Research CORECORE is an ERM platform developed in within a research environment and aims to automatize
internal management processes, like human resources, orders, budgets, suppliers, funds, equipment \rooms accesses and maintenance and publications.The project is distributed as an open-source project to facilitate the adaptation of the
ERM to each institution's needs.
Package: core-commons
Core CommonsEsta librería implementa métodos y utilidades comunes que serán necesarios en múltiples proyectos, como validación de datos, o configuraciones generales de scripts.RequisitosLos requisitos para instalar y ejecutar el proyecto son:Un IDE o un editor de código:IDE:PyCharmEditores de Código:Visual Studio Code,Notepad++,VIMUn entorno dePython 3.6.8mínimo.InstalaciónPara instalar el programa localmente o en un Linux remoto:Descargar o clonar el proyecto desde el repositorio.Asegurarse de tener un entorno de Python funcional con la versión requerida y los paquetes necesarios.Activar el entorno de Python que fue creado.Instalar el módulo ejecutando este comando en la ruta del proyecto:pythonsetup.pyinstallConfiguraciónEste proyecto no tiene ficheros de configuración o ninguna configuración adicional.
Package: corecon
![](logo.png)[![DOI](https://zenodo.org/badge/224433919.svg)](https://zenodo.org/badge/latestdoi/224433919)
[![DOI](https://joss.theoj.org/papers/10.21105/joss.05407/status.svg)](https://doi.org/10.21105/joss.05407)CoReCon: open collection of Reionization ConstraintsCoReConis an open collection of constraints on various physical
quantities linked to theEpoch of Reionization (EoR).It is built to be easily complemented by contribution from the scientific
community, thanks to a simple data form that supports two different ways of
input data.CoReCon takes care of loading and interpreting the data, and presenting them
in an organic and ready-to-use way. It also implement simple slicing capabilities,
which allow to perform simple data filtering.Seehttps://corecon.readthedocs.io/en/latest/for the latest documentation.
Package: core-ct
Core-CTThecore-ctscan library was built to assist geologists with the visualization and analysis of the CT scans of rock cores.Documentationhttps://core-ct.readthedocs.io/en/latest/Development EnvironmentInstallpoetryusing the instructions athttps://python-poetry.org/docs/#installationNavigate to inside the repositoryRunpoetry installto install the required dependenciesUsepoetry shellto activate the newly created virtual environmentLintingTo help maintain a clean codebase, this project makes use of therufflinter. Due to settings in the GitHub repository, branches cannot be merged intomainunless they pass linting checks.Pre-Commit HooksAs such, this repository also supports the Pythonpre-commitlibrary, which can be used to install a git pre-commit hook that requires the code to pass a linting check before it can be committed. These pre-commit hooks are defined in the.pre-commit-config.yaml.To set up this linting hook perform the following actions:Runpoetry installto installpre-commitandruffRunpoetry run pre-commit installto install the commit hooksManually Run the LinterIf you would prefer to manually run a linting check, simply use the following command.poetry run ruff .Auto-FormattingAdditionally, the Python libraryblackhas been specified as a development dependency for this project and it can be used to automatically format code to match the linting rules.Visual Studio CodeFinally, if Visual Studio Code is being used as a development IDE, it has support for bothruffandblackextensions to help with catching linting errors and autoformatting code.https://marketplace.visualstudio.com/items?itemName=charliermarsh.ruffhttps://marketplace.visualstudio.com/items?itemName=ms-python.black-formatterhttps://code.visualstudio.com/docs/python/formattingTestingJust as with linting, due to settings in the GitHub repository, branches cannot be merged intomainunless they pass all tests as specified in thetestsrepository.To run these tests simply use the following command:poetry run pytestResourceshttps://github.com/mrsiegfried/SiegVent2023-Geologyhttps://osu-mgr.org/sedctCreditsThis software was built by the Golden Rocks team as a part of the Fall 2023 session of the Colorado School of Mines'CSCI-370course.AuthorsCarla Ellefsen, Kira Hanson, Connor Sparks, Asa SprowSponsorsZane Jobe, Ryan Venturelli
Package: core-curate-registry-app
Core Curate Registry AppCuration functionalities specific to the Registry application for the curator core project.Quick start1. Add “core_curate_registry_app” to your INSTALLED_APPS settingINSTALLED_APPS=[...'core_curate_registry_app','core_curate_app',]2. Include the core_curate_registry_app URLconf in your project urls.pyurl(r'^curate/',include('core_curate_registry_app.urls')),
Package: core-custom-queries-app
Core Custom Queries AppCustom Queries feature for the curator core project.Configuration1. Add “core_custom_queries_app” to your INSTALLED_APPS setting like thisINSTALLED_APPS=[..."core_custom_queries_app",]2. Include the core_custom_queries_app URLconf in your project urls.py like thisurl(r'^',include("core_custom_queries_app.urls")),
Package: core-dashboard-registry-app
Core Dashboard Registry AppResource management via a dashboard for the registry core project.Quickstart1. Add “core_dashboard_registry_app” to your INSTALLED_APPS settingINSTALLED_APPS=[...'core_dashboard_registry_app',]2. Include the core_dashboard_registry_app URLconf in your project urls.pyurl(r'^dashboard/',include('core_dashboard_registry_app.urls')),
Package: core-data-structures
core-data-structuresThis project/library contains commons data structures...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage
Package: core-datetime
core-datetimeThis project/library contains common elements related to date & time...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage
Package: core-db
core-dbThis project/library contains common elements related to database engines...Execution EnvironmentInstall librariespip install --upgrade pip 
pip install virtualenvCreate the Python Virtual Environment.virtualenv --python=python3.11 .venvActivate the Virtual Environment.source .venv/bin/activateInstall required libraries.pip install .Check tests and coverage...python manager.py run-test
python manager.py run-coverage