Saravanan666/pypi-org huggingface dataset:
Package: core-pytorch-utils
Core PyTorch Utils (CPU)This package is a light-weight core library that provides the most common and essential functionalities shared in various deep learning tasks:Trainer: does tedious training logic for you.LRWarmupScheduler: wraps all standard PyTorch LR scheduler to support warmup.ConfigArgumentParser: provides an argument parser that supports loading a YAML configuration file.......You can find a brief Chinese introduction atzhihu.InstallationFrom PyPI.pip install core-pytorch-utilsOr from source.git clone https://github.com/serend1p1ty/core-pytorch-utils.git
cd core-pytorch-utils
pip install -r requirements.txt
pip install -v -e .Getting StartedInexamples/folder, we show how to use our Trainer to train a CNN on MINIST.It isstronglyrecommended that you run this code before using the CPU library.AdvancedLearn more from ourdocumentaion.ContributingPull request is welcomed! Before submitting a PR,DO NOTforget to run./dev/linter.shthat provides syntax checking and code style optimation.LicenseCPU is released under theMIT License.AcknowledgmentsWe referedmmcv,detectron2andpytorch-image-modelswhen develping CPU.
Package: core-reimbursements
CORE REIMBURSEMENTSIt is a module of the Research CORE ERM which implements the models related to reimbursements.ReimbursementsReimbursements expensesInstallationpipinstallcore-reimbursementsEnterprise 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-research
CORE RESEARCHIt is a module of the Research CORE ERM which implements the models related to research output.PublicationsJournalsProjectsInstallationpipinstallcore-researchEnterprise 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: corescan-plotting
corescan_plotting=======corescan_plottingcontains tools for analyzing and plotting outputs from various core scanning instruments located at the USGS Pacific Coastal and Marine Science Center.SetupFor USGS python users, I recommend usingMiniconda.Install the appropriate Python 3.x Miniconda installer. If on Windows, chooseJust Meand for location, something likeC:\Users\USERNAME\Miniconda3, but this is up to you. If this is your first tie working with conda environments, IOOS has auseful guideon setting up conda on both macos and windows and is perhaps a good place to start before creating a new conda environment for the corescan_plotting package.Create a conda environment (see:conda.io) with python=3.7Once created, activate the environment and install corescan_plotting with:conda install -c spmls corescan_plottingThis installs the latest stable version.opencv is a tricky dependency to install, you may have to reinstall it with:pip install opencv-python==4.2.0.32ifcorescan_plotting fails to import in python.UsageSeeexamples.ipynbfor more detailed examples.from corescan_plotting import ct

import matplotlib.pyplot as plt



im, xml = ct.ct_in() # this will open up a window to load in a Geotek orthogonal view image and associated xml file

ct.ct_plot(im, xml) # this will plot the loaded ct file

plt.show()
Package: core-schema-viewer-app
Schema Viewer feature for the curator core project.Configuration1. Add “core_schema_viewer_app” to your INSTALLED_APPS setting like thisINSTALLED_APPS=[..."core_schema_viewer_app",]2. Include the core_schema_viewer_app URLconf in your project urls.py like thisurl(r'^',include("core_schema_viewer_app.urls")),3. Oxygen configurationForproductionenvironment, follow the steps described in Oxygen.prod.README.rstFordevelopmentenvironment, follow the steps described in Oxygen.dev.README.rst
Package: coresets
CoresetsThis library contains the implementation coreset generation for k-Means and (Bayesian) Gaussian mixture models.
It also offers the extended versions of the corresponding algorithms that support weighted data sets.To get started, take a look at:examples/intro.ipynb(this is a fork ofhttps://github.com/zalanborsos/coresets, intended to fix installation issues + publish to pypi)SetupInstallpoetry.poetrybuild
poetryinstallRunning testsIn project root run:poetryrunpytestReferencesThe implementation of the library is based on the following works:Bachem, O., Lucic, M., & Krause, A. (2017). Practical coreset constructions for machine learning. arXiv preprint arXiv:1703.06476.Bachem, O., Lucic, M., & Krause, A. (2017). Scalable and distributed clustering via lightweight coresets. arXiv preprint arXiv:1702.08248.Lucic, M., Faulkner, M., Krause, A., & Feldman, D. (2018). Training Gaussian Mixture Models at Scale via Coresets. Journal of Machine Learning Research, 18, Art-No.Borsos, Z., Bachem, O., & Krause, A. Variational Inference for DPGMM with Coresets. (2017). Advances in Approximate Bayesian InferencePublishing a new versionrm-rfbuilddist
poetrybuild
rename-v's/manylinux_2_\d+/manylinux1/'dist/*.whl# Rename the wheel to manylinux1 as we don't use advanced LIBC featspoetrypublish
Package: cores-ft
Cores_ftMonitora a temperatura e frequências dos cores.Para obter a frequencia dos cores foi usado o arquivo/proc/cpuinfo.Para obter as temperatura do cores foi utilizado o utilitáqriosensorsdo pacotelm_sensorsComo usarCriando o ambiente virtual e instalando pelo pippython -m venv .venv_test --upgrade-depspip install cores_ftPara rodar basta fazer:python -m cores_ft
Package: coresptbr
cores_ptbrUm pacote simples de cores em português escrito em Python.
Você pode ver o códigoaqui.Como usar?Para usar esse pacote, basta importá-lo em seu código python:fromcoresptbrimportcoresEsse pacote tem a funçãocolorir(), que retorna o valor dentro da função com algumas cores/estilos diferentes:cores.colorir('Hello, world!','mag','neg')O código acima irá retornar a string 'Hello, World!' em negrito ('neg') e com texto em magenta ('mag').
A maioria das cores/estilos são escritos de forma abreviada. Segue abaixo a abreviação de cada uma:cores={'neg':'1',# Negrito'fraco':'2',# Fraco'ita':'3',# Itálico'sub':'4',# Sublinhado'pis':'5',# Piscar'inv':'7',# Inverter'pre':'30',# Preto'vm':'31',# Vermelho'vd':'32',# Verde'ama':'33',# Amarelo'azu':'34',# Azul'mag':'35',# Magenta'cia':'36',# Ciano'bra':'37',# Branco'prec':'90',# Preto-claro'vmc':'91',# Vermelho-claro'vdc':'92',# Verde-claro'amac':'93',# Amarelo-claro'azuc':'94',# Azul-claro'magc':'95',# Magenta-claro'ciac':'96',# Ciano-claro'brac':'97',# Branco-claro (Por incrível que pareça existe.)'fpre':'40',# Fundo preto'fvm':'41',# Fundo vermelho'fvd':'42',# Fundo verde'fama':'43',# Fundo amarelo'fazu':'44',# Fundo azul'fmag':'45',# Fundo magenta'fcia':'46',# Fundo ciano'fbra':'47',# Fundo branco'fprec':'100',# Fundo preto-claro'fvmc':'101',# Fundo vermelho-claro'fvdc':'102',# Fundo verde-claro'famac':'103',# Fundo amarelo-claro'fazuc':'104',# Fundo azul-claro'fmagc':'105',# Fundo magenta-claro'fciac':'106',# Fundo ciano-claro'fbrac':'107'# Fundo branco-claro}É possível deduzir o nome das cores, basta colocar as primeiras três letras.
Branco ->'bra', Amarelo ->'ama'e assim por diante.
Vermelho e Verde são'vm'e'vd'por terem as mesmas três letras iniciais.
Para cores claras basta adicionar um 'c' na frente do nome da cor
(Amarelo-claro ->'amac').
Para colocar o fundo de uma cor basta adicionar um 'f' antes.
(Fundo verde ->'fvd', Fundo preto-claro ->'fprec').A funçãocolorir()permite no máximo 3 parâmetros de cor/estilo:Estilo do texto (1-7);Cor da letra (30-37, 90-97);Cor de fundo (40-47, 100-107);
Package: core-suppliers
CORE SUPPLIERSIt is a module of the Research CORE ERM which implements the models related to suppliers.Suppliers infoSuppliers categoriesInstallationpipinstallcore-suppliersEnterprise 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-tests
core-testsThis project contains basic elements for testing purposes and the ability
to run tests and coverage as a command...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 manage.py run-test
python manage.py run-coverage
Package: core-test-utils
test-utilsUsingpython -m pip install core_test_utilsBuidlingIncrease the version insetup.cfgfileCreate a file ~/.pypirc in root directory of your system and paste below data in the file.[distutils]
 index-servers =
         local

 [local]
 repository = https://upload.pypi.org/legacy/After making changes in the test_utils go to source directory of code and run below command to build the wheel and push to artifactory- python3 -m pip install --upgrade build
 - python3 -m build
 - python3 -m pip install --upgrade twine
 - python3 -m twine upload --repository local --verbose dist/*
 - Enter the username and password of your pypi accountThat's all you have to do and now you are good to use the core_test_utils in your project
Package: core-user-registration-app
core_user_registration_appUser registration module for the core project.Quick start1. Add “core_user_registration_app” to your INSTALLED_APPS settingINSTALLED_APPS=[...'core_user_registration_app',]2. Include the core_user_registration_app URLconf in your project urls.pyre_path(r'^',include('core_user_registration_app.urls')),
Package: core-validator
Core-ValidatorErrorSchemaUse core_validator.ErrorSchema if you don't know which format you're gonna use.Quick StartDTOclassCommentDto(BaseModel):comment:strpost_id:intowner_id:intAdd error source (error context)classSource(BaseModel):local:strDTO Validator@dataclasses.dataclass()classCommentValidator(Validator[CommentDto,ErrorSchema[Source]]):@validateasyncdeftest1(self):post_ids=list(range(1,10))ifself.data.post_idnotinpost_ids:self.context.add_error(ErrorSchema(code=ErrorCodeEnum.not_found.value,message="Id doen't not exists",detail=f"Post with id={self.data.post_id}not found",source=Source(local="data/post_id",),))@validate@pre_state(lambdaself:self.data.owner_id>0,negative_id_error)asyncdeftest2(self):owner_ids=list(range(1,10))ifself.data.owner_idnotinowner_ids:self.context.add_error(ErrorSchema(code=ErrorCodeEnum.not_found.value,message="Id doen't not exists",detail=f"User with id={self.data.post_id}not found",source=Source(local="data/owner_id",),))Useasyncdeffunction():validator=CommentValidator()errors=awaitvalidator.errors(comment)# orawaitvalidator.validate()# raise ValidationError
Package: core-visualization-insitu-app
Visualization feature for the curator core project.Configuration1. Add “core_visualization_insitu_app” to your INSTALLED_APPS setting like thisINSTALLED_APPS=[..."core_visualization_insitu_app",]2. Include the core_visualization_insitu_app URLconf in your project urls.py like thisre_path(r'^visualization-insitu/',include("core_visualization_insitu_app.urls")),
Package: corevolution
1. corevolutionThere is no (r)evolution withoutcorevulution. Yes, I did it again. A bad pun.But it's more than a Haiku. So what(?!) is it? Check the documentation.1. corevolution1.1. Why?1.2. What?LearningPhilosophy1.1. Why?I can't depend any longer on third party libraries to do the heavy lifiting. Finding and fixing errors takes too long.I get it - Some innovations are great and maybe my style is puristic.My calculations per ms grow constantly because of better hardware. My conclusion? Build purisitic and minimalistic calculations!The philosophy seperates me from the rest and never let me down.1.2. What?We all do it and we want it. You want it. I want it. Linear algebra. In C.LearningThere is a lot of stuff to learn, and I don't know a lot about shipping C Code. Bear with me for a while, your patience will be rewarded. Total freedom political zones. Just coding matters here.PhilosophyThere is no numpy involved. We aim for standard library - nothing else.
Package: core-watpy
Python Waveform Analysis ToolsTheCoRepython package for the analysis of gravitational waves. It incorporates various functions based on previous codesscidata,WATandpyGWAnalysis, and includes classes to work with theCoRe waveform database.InstallationPyPiRun the commandpip install core-watpy. Note that to use this package one needs to typewatpyonly, e.g.import watpy.From sourceThe installation relies on standard Python librarysetuptools.
Once the repository is cloned, the installation can be performed in two ways,
depending on the choice of the user:Run the commandpython setup.py installorpython setup.py install --userinside the project directory.Install the module viapiprunning the commandpython -m pip installinside the project directory. It is possible to include the--useroption and the-eoption for editing.Requirementswatpyworks with Python3.
The following Python packages are required for installation:Numpy(Python array-handler)Scipy(Python scientific library)Matplotlib(Nice visualization package)H5py(Pythonic interface to HDF5)For users interested in interactive usage of this package we suggest ipython notebooks. These can be installed with the following packages:iPython(Strictly better version of the basic python shell)Jupyter(Notebooks, slides, HTML conversion of notebooks and more)To sync and clone the CoRe DBwatpyrequires a git installation:gitversion control systemgit-lfsAPI (Large File Storage)Contentwatpyimplements few classes to clone and work with CoRe waveforms.wave()andmwaves()for multipolar waveforms data, seewave.pyCoRe_db()to clone the CoRe DB, add data etc, seecoredb.pyCoRe_idx()to work with theCoRe DB index, seecoredb.pyCoRe_sim()to work with simulation data in a CoRe repository, seecoredb.pyCoRe_run()to work with one simulation run data in a CoRe repository, seecoredb.pyCoRe_h5()to work with HDF5 data, seecoredb.pyCoRe_md()to manage the metadata, seemetadata.pyPlease note that in order to use this package one needs to typewatpyonly, e.g.import watpy.Seewatpy_CoReDB.ipynbandwatpy_wave.ipynbfor our tutorials on the CoRe DB and waveforms.FeaturesClasses for multipolar waveform dataClasses to clone theCoRe databaseGravitational-wave energy and angular momentum calculation routinesPsi4-to-h via FFI or time integral routinesWaveform alignment and phasing routinesWaveform interpolation routinesWaveform's spectra calculationRichardson extrapolationWave objects contain already information on merger quantities (time, frequency)Unit conversion packageCompatible numerical-relativity file formats: BAM, Cactus (WhiskyTHC / FreeTHC), CoRe databaseVersionsCode versions are tagged asMAJOR.MINOR.PATCHfollowingsemantic versioningLatest version
Package: core-website-app
Basic web functionalities for the curator core project.Quickstart1. Add “core_website_app” to your INSTALLED_APPS settingINSTALLED_APPS=[...'core_website_app',]2. Include the core_website_app URLconf in your project urls.pyurl(r'^website/',include('core_website_app.urls')),3. Install and configure CaptchaSee instructions:https://django-simple-captcha.readthedocs.io/en/latest/usage.html#installation
Package: corfu
corfuThecorfulibrary computes exact equal-time or unequal-time angular
correlation functions and power spectra by projecting three-dimensional
correlation functions or power spectra onto the sphere in real space.Maintainers:Nicolas Tessore, Lucia F. de la BellaGetting StartedPlease refer to thedocumentation, where you can findthetheorybehind thecorfupackage,resultsto demonstrate that the package works as intended,an explanation ofhow to usethe package, andthefunction reference.InstallationThe easiest way to install thecorfumodule is via pip:$ pip install corfuYou can install thecorfumodule from a local working directory, such as a
repository clone:$ cd corfu
$ ls
corfu.py    setup.py    ...
$ pip install .Alternative, thecorfu.pyfile is self-contained and can be copied to where
it is required:$ cd myproject
$ cp ../corfu/corfu.py .
$ python
>>> import corfu  # worksUsageTo project 3d (matter) correlation functions or power spectra along lines of
sight and obtain angular correlation functions or angular power spectra:Use thecorfu.ptoxi()function to obtain the 3d (matter) correlation
function from the 3d (matter) power spectrum.Use thecorfu.uneqt()function to obtain the projected angular correlation
function from the 3d (matter) correlation function.Use thecorfu.wtocl()function to obtain the angular power spectrum from the
angular correlation function.For further guidance, see thedocumentation, and in particular theusagepage.  For an explanation of how the computation works, see thetheorypage.
Package: corgi-cli
corgiA new thing for doggo.ninjaThis is a cli for doggo.ninja, it should be pretty helpful and useful.Refrence:Usage:
    corgi.py
    corgi.py ls
    corgi.py user
    corgi.py upload [-d | --dir] <path>
    corgi.py delete [--all] [<originalName>]
    corgi.py -v

Options:
    <path>  Optional path argument.
    <originalName>  The original name of the file to be manipulated.Examples:Uploadfile.txt:python corgi.py upload file.txtUpload every file from a directory:python corgi.py upload --dir directoryGet user info:python corgi.py userDeletefile.txtfrom doggo.ninja:python corgi.py delete file.txtDeleteeveryfile from doggo.ninja:python corgi.py delete --all
Package: corgie
COnnectomics Registration Generalizable Inference Engine (corgie)Welcome to corgie! corgie is a command line tool built for registration of very large 3D volumes.Installationpip install corgieExamplecorgie copy \
--src_layer_spec '{
   "name": "unaligned",
   "path": "https://s3-hpcrc.rc.princeton.edu/minnie65-phase3-em/unaligned"
   }' \
--src_layer_spec '{
   "name": "large_folds",
   "type": "mask",
   "path": "gs://seunglab_minnie_phase3/alignment/unaligned_fold_lengths/threshold_350"
   }' \
--dst_folder "gs://corgie/demo/my_first_stack" \
--start_coord "150000, 150000, 17000" \
--end_coord "250000, 250000, 17020" \
--mip 6 \
--chunk_xy 1024 --chunk_z 1DocumentationLink
Package: corgipath
CorgiPath: Customizable Path PlannerHere is a simple flow chart:flowchart LR

c("Collision Layer")
s("Search-space Layer")

plan("Planning Module")
post("Postprocessing Module\n(optional)")
v("Matplot Viewer\n(optional)")

c --> plan
s --> plan

plan -.-> post
plan -.-> v
post -.-> v

style c stroke:#f66,stroke-width:2px
style s stroke:#f66,stroke-width:2px
style plan stroke:#f66,stroke-width:2px
style post stroke-width:2px,stroke-dasharray: 5 5
style v stroke-width:2px,stroke-dasharray: 5 5InstallationBuild your own plannerDevelopment in vscodepoetry config virtualenvs.in-project true
poetry config virtualenvs.path "./.venv"ContributeThanks for taking the time to contribute!We recommend developing ina virtual environment using Poetry.
Package: corgy
corgyCorgy is a Python library that allows you to create feature rich data
classes using intuitive type annotations.>>>fromtypingimportList>>>fromtyping_extensionsimportLiteral>>>fromcorgyimportCorgy>>>fromcorgy.typesimportKeyValuePairs>>>classG(Corgy):...x:int...y:Literal["y1","y2","y3"]>>>classC(Corgy):...x:List[float]=[1.0,2.0]...y:KeyValuePairs[str,int]...g:GFeaturesType checking:Corgyinstances are type-checked, and support a
number of type modifiers.>>>fromtypingimportTuple>>>classC(Corgy):...x:int...y:Tuple[int,int]>>>C(x="1")Traceback (most recent call last):...ValueError:error setting `x`: invalid value for type '<class 'int'>': '1'>>>C(y=(1,2,3))Traceback (most recent call last):...ValueError:error setting `y`: invalid value for type 'typing.Tuple[int, int]': (1, 2, 3): expected exactly '2' elementsDictionary interface:Corgyinstances can be converted to/from
dictionaries.>>>classG(Corgy):...x:int>>>classC(Corgy):...x:int...g:G>>>g=G.from_dict({"x":1})>>>gG(x=1)>>>c=C(x=2,g=g)>>>c.as_dict(){'x': 2, 'g': {'x': 1}}Command-line parsing:Corgyclass attributes can be added to anArgumentParserinstance, and parsed from the command-line. Help
messages can be added to attributes withAnnotated, and will be
passed to the command line parser.>>>fromargparseimportArgumentParser>>>fromtypingimportOptional>>>fromtyping_extensionsimportAnnotated>>>classArgGroup(Corgy):...arg1:Annotated[Optional[int],"optional number"]...arg2:Annotated[bool,"a boolean"]>>>classMyArgs(Corgy):...arg1:Annotated[int,"a number"]=1...arg2:Annotated[Tuple[float,...],"at least one float"]...grp1:Annotated[ArgGroup,"group 1"]>>>parser=ArgumentParser(usage="")>>>MyArgs.add_args_to_parser(parser)>>>parser.print_help()# doctest: +SKIPusage:optional arguments:-h, --help            show this help message and exit--arg1 ARG1           a number--arg2 ARG2 [ARG2 ...]at least one floatgrp1:group 1--grp1:arg1 [GRP1:ARG1]optional number--grp1:arg2, --no-grp1:arg2a booleanEnhanced argparse formatting: Thecorgypackage providesCorgyHelpFormatter, a formatter class forargparse, with support
for colorized output. It can also be used independent ofCorgyclasses.>>>fromcorgyimportCorgyHelpFormatter>>># `ArgGroup` and `MyArgs` as defined above>>>parser=ArgumentParser(usage="",formatter_class=CorgyHelpFormatter)>>>MyArgs.add_args_to_parser(parser)>>>parser.print_help()# doctest: +SKIPConvenience types:corgy.typesprovides a number of types for
converting strings into objects like paths, dictionaries, classes,
etc. These can be used standalone, but are especially useful for
parsing from command line arguments. Refer to the docs for details on
all available types. A small example is shown below.>>>T=KeyValuePairs[str,int]>>>m=T("x=1,y=2")>>>print(m){'x': 1, 'y': 2}Installcorgyis available on PyPI, and can be installed with pip:pipinstallcorgySupport for colorized output requires thecrayonspackage, also
available on PyPI. You can pull it as a dependency forcorgyby
installing with thecolorsextra:pipinstallcorgy[colors]ParsingCorgyobjects fromtomlfiles requires thetomlipackage
on Python versions below 3.11. This can be installed automatically with
thetomlextra:pipinstallcorgy[toml]
Package: coriolis
CoriolisWhat is it ?coriolisis a quick visualization python software developped using PyQt5 and xarray.
It allows the user to get a quick insight of a NetCDF (.nc) file.It provides multi-dimensional field main statistics, an embedded matplotlib canvas
to visualize the data (1-D and 2-D plots) and some features to save
the figure, scale the data, change the colorbar, use non-linear axis scales and othersAn animation widget is also implemented. However, at this point, matplotlib is not fast enough to enable a
confortable and quick visualization refreshment. Other software such as NcView should be used instead.More importantly,coriolisallows the user to precisely select the data to plot, namely the needed slices
can be easily given.How to install it ?You need to install the dependencies before installing the package. They were
not included within the package due to some issues with pip-installed PyQt5
package.
We recommend therefore the Anaconda distribution for installing those dependencies.In a pre-activated python3 environment, you can simply do :$ conda install matplotlib xarray netcdf4 cartopy`
$ pip install coriolis## How to use it ?As for now, only NetCDF (.nc) files can be processed.You can use the software by running the command :$ coriolis yourfile.ncHow to customize it ?If you want to customize the figures style,
you can modify the custom.mplstyle file which is in the package.