Saravanan666/pypi-org huggingface dataset:
Package: condor-tensorflow
Condor Ordinal regression in Tensorflow KerasTensorflow Keras implementation of CONDOR Ordinal Regression (aka ordinal classification) by
Garrett Jenkinson et al (2021).CONDOR is compatible with any state-of-the-art deep neural network architecture,
requiring only modification of the output layer, the labels, and the loss function.Read our full documentation to learn more.We also have implementedCONDOR for pytorch.This package includes:Ordinal tensorflow loss function:CondorOrdinalCrossEntropyOrdinal tensorflow error metric:OrdinalMeanAbsoluteErrorOrdinal tensorflow error metric:OrdinalEarthMoversDistanceOrdinal tensorflow sparse loss function:CondorSparseOrdinalCrossEntropyOrdinal tensorflow sparse error metric:SparseOrdinalMeanAbsoluteErrorOrdinal tensorflow sparse error metric:SparseOrdinalEarthMoversDistanceOrdinal tensorflow activation function:ordinal_softmaxOrdinal sklearn label encoder:CondorOrdinalEncoderInstallationInstall the stable version via pip:pipinstallcondor-tensorflowAlternatively install the most recent code on GitHub via pip:pipinstallgit+https://github.com/GarrettJenkinson/condor_tensorflow/condor_tensorflowshould now be available for use as a Python library.Docker containerAs an alternative to the above, we provide a convenient Dockerfile that will build a container withcondor_tensorflowalong with all of its dependencies (Python 3.6+, Tensorflow 2.2+, sklearn, numpy).
This can be used as follows:# Clone this git repositorygitclonehttps://github.com/GarrettJenkinson/condor_tensorflow/# Change directory to the cloned repository rootcdcondor_tensorflow# Create a docker imagedockerbuild-tcpu_tensorflow-fcpu.Dockerfile./# run image to serve a jupyter notebookdockerrun-it-p8888:8888--rmcpu_tensorflow# how to run bash inside container (with Python that will have required dependencies available)dockerrun-u$(id-u):$(id-g)-it-p8888:8888--rmcpu_tensorflowbashAssuming a GPU enabled machine with NVIDIA drivers installed replacecpuabove withgpu.ExampleThis is a quick example to show basic model implementation syntax.Example assumes existence of input data (variable 'X') and ordinal labels (variable 'labels').importtensorflowastfimportcondor_tensorflowascondorNUM_CLASSES=5# Ordinal 'labels' variable has 5 labels, 0 through 4.enc_labs=condor.CondorOrdinalEncoder(nclasses=NUM_CLASSES).fit_transform(labels)model=tf.keras.Sequential()model.add(tf.keras.layers.Dense(32,activation="relu"))model.add(tf.keras.layers.Dense(NUM_CLASSES-1))# Note the "-1"model.compile(loss=condor.CondorOrdinalCrossEntropy(),metrics=[condor.OrdinalMeanAbsoluteError()])model.fit(x=X,y=enc_labs)See this colab notebookfor extended examples of ordinal regression with MNIST and Amazon reviews (universal sentence encoder).Please post any issues to theissue queue.Acknowledgments: Many thanks tothe CORAL ordinal authorsandthe CORAL pytorch authorswhose repos provided a roadmap for this codebase.ReferencesJenkinson, Khezeli, Oliver, Kalantari, Klee. Universally rank consistent ordinal regression in neural networks, arXiv:2110.07470, 2021.
Package: condu
# Condu a Python 3.6 client for Conductor
The previous client was written in python 2.7.This client was built upon the previous work and extended with
added functionalities and performance boosts.Provides 3 sets of functions:Workflow management APIs (start, terminate, get workflow status etc.)Worker execution frameworkTask and Workflow definitions## Install` pip install condu `## Using Workflow Management API
Python class`Condu`provides client API calls to the conductor server to start manage the workflows.
Package: conduction
ConductionImplicit heat conduction solver on a structured grid written in Python. It interfaces with PETSc to provide highly scalable meshes and solve the steady-state heat equation using direct or iterative methods.DependenciesPython 2.7 and aboveNumpy 1.9 and aboveScipy 0.14 and abovempi4pypetsc4pyh5py(optional - for saving parallel data)Matplotlib (optional - for visualisation)PETSc installationPETSc is used extensively via the Python frontend, petsc4py. It is required that PETSc be configured and installed on your local machine prior to using this module. You can use pip to install petsc4py and its dependencies.pipinstall[--user]numpympi4py
pipinstall[--user]petscpetsc4pyIf that fails, you mustcompilethese dependencies manually.UsageAll of the scripts in thetestsdirectory can be run in parallel, e.g.mpirun -np 4 python conduction3d_benchmark.pywhere the number after thenpflag specifies the number of processors.APIAConductionNDobject can be defined based on the extent of the domain and the number of cells. The simplified use-case below outlines the following tasks:Define a mesh on which to solve the heat equationPopulate the thermal conductivity and heat production fieldsSet boundary conditions on the top and bottom wallsSolve for temperaturefromconductionimportConductionND# define the meshminX,minY,minZ=0.0,0.0,0.0maxX,maxY,maxZ=1.0,1.0,1.0resX,resY,resZ=10,10,10mesh=ConductionND((minX,minY,minZ),(maxX,maxY,maxZ),(resX,resY,resZ))# populate thermal conductivity and heat production fieldsn=resX*resY*resZk=np.ones(n)H=np.ones(n)mesh.update_properties(k,H)# set boundary conditionsmesh.boundary_condition("maxZ",0.0,flux=False)# Dirichlet BCmesh.boundary_condition("minZ",1.0,flux=True)# Neumann BC# solve temperatureT=mesh.solve()More complex examples can be found in theExamplesdirectory.
Package: conducto
ConductoWebsite:conducto.comDocs:Hello WorldCI/CDConceptsDemo VideoExample CodeConducto is a CI/CD toolHere are some things that set it apart:Use Python instead of YAML (Javascript API coming soon).Explore a tree (not a DAG).Fix with local editors,debugin local containers.Move workloads between--localand--cloudwith a single argument.Computational PipelinesConsider a computational task that breaks into pieces (and maybe its pieces have pieces too).Conducto organizes those pieces into trees that we call pipelines.
Atconducto.comwe host pages that let you view and control them.Centralize Insights, Work WhereverConducto is good for those long running tasks that people like to check in on.
It provides a place where they can watch them happen (even if they're running on your dev box).Conducto pipelines are fully encapsulated in containers, so they're portable.
All you need is a Docker, a web browser, and a Conducto account (which is free).The only paid feature iscloud mode, which is where we provide the compute power instead of leaning on your local Docker daemon.Try ItYou'll need Python 3.6 or higher andDocker.
Use pip to install:pip install conductoA Sample PipelineStart with a script like this:# pipeline.py
import conducto as co

py_code = 'print("Hello")'
js_code = 'console.log("World!")'

def pipeline() -> co.Serial:
    root = co.Serial()
    root["hello from python"] = co.Exec(f"python -c '{py_code}'")
    root["world from javascript"] = co.Exec(f"echo '{js_code}' | node -",
                                            image="node:current-alpine")
    return root

if __name__ == "__main__":
    co.main(default=pipeline)Launch it like this:python pipeline.py --localYou'll be prompted to create a Conducto account, and then you'll see your pipeline.ContactIf you want to chat,join us on Slack.If you run into problems feel free to use theconductotag on Stack Overflow or file a GitHub issue on this repo.
Package: conductor_celery
conductor-celeryThis project is a test!!! Do not use itThis is a template repository for Python projects that use Poetry for their dependency management.Github repository:https://github.com/tomas_correa/conductor-celery/Documentationhttps://tomas_correa.github.io/conductor-celery/Getting started with your projectFirst, create a repository on GitHub with the same name as this project, and then run the following commands:gitinit-bmain
gitadd.
gitcommit-m"init commit"gitremoteaddorigingit@github.com:tomas_correa/conductor-celery.git
gitpush-uoriginmainFinally, install the environment and the pre-commit hooks withmakeinstallYou are now ready to start development on your project! The CI/CD
pipeline will be triggered when you open a pull request, merge to main,
or when you create a new release.To finalize the set-up for publishing to PyPi or Artifactory, seehere.
For activating the automatic documentation with MkDocs, seehere.
To enable the code coverage reports, seehere.Releasing a new versionCreate an API Token onPypi.Add the API Token to your projects secrets with the namePYPI_TOKENby visitingthis page.Create anew releaseon Github.
Create a new tag in the form*.*.*.For more details, seehere.Repository initiated withfpgmaas/cookiecutter-poetry.
Package: conductor-cli
🎶 ConductorConductor is a simple and elegant tool that helps with orchestrating your
research computing. Conductor helps with automating your research computing
pipeline, all the way from experiments to figures in your paper.Note:Conductor is still under active development. Its usage and system
requirements are subject to change between versions. Conductor uses semantic
versioning. Before the 1.0.0 release, backward compatibility between minor
versions will not be guaranteed.InstallationConductor requires Python 3.8+ and is currently only supported on macOS and
Linux machines. It has been tested on macOS 10.14 and Ubuntu 20.04.Conductor is available on PyPI and so it can be installed usingpip.pipinstallconductor-cliAfter installation, thecondexecutable should be available in your shell.cond--helpNote that if you install Conductor locally on a Linux machine (e.g., usingpip install --user conductor-cli), you may need to add$HOME/.local/binto your$PATHto get access to thecondexecutable in your shell.Documentation and Getting StartedA quick way to get started is to look at the example projects under theexamplesdirectory. For more details, please check out Conductor's reference
documentationhere.AcknowledgementsConductor's interface was largely inspired byBazelandBuck.
Package: conductor-grpc
To regenerate python proto, download new proto files fromhttps://github.com/Netflix/conductor/tree/master/grpc/src/main/protoRename the directory grpc to conductor grpc. Rename any imports in the proto files referencing grpc to be conductor_grpc.
Then runpython -m grpc_tools.protoc -I=proto --python_out=. --grpc_python_out=. proto/*/*.proto
Package: conductor.maya
Conductor-MayaConductor-Maya is Maya plugin that contains a Submitter for the Conductor Cloud rendering service.InstallationUse the package managerpipto install Conductor-Maya.pipinstallconductor.mayaYou can install conductor.maya either globally or in avirtual environment. In either case, after installation, you'll need to create a module file to let Maya know where it is installed.Run the following script to automatically create a Maya module file.setup_mayaUsageThe plugin provides aconductorRendernode to submit rendering jobs based on values in Maya'sRenderSettingsnode.To set up a render:Open a scene that's ready to render.Use the Plugin Manager to load the Conductor plugin. A Conductor Menu will appear in the main menu bar.ChooseConductor->Submitter->Create.In the attribute editor, pressConnect to Conductorand sign in if necessary.Choose an instance type and set up other parameters as required.Press submit.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseBSD 3 Clause
Package: conduit
ConduitPython stream transformation package for common Power Engineering analytics.Conduit integrates withbtrdb-pythonto support a series of common power engineering analytics on synchrophasor data queried from a BTrDB database. These transformations are applied to Pandas Series and DataFrame objects that have been materialized through database queries alongside the tags and annotations that provide metadata for each stream. Currently the following transformations are implemented:ConversionsPer UnitLine to LineLine to NeutralAmpsCalibrateRadiansDegreesPhasorRealImaginaryComplex PhasorPhasor PairComplex Power (P + jQ)Real Power (P)Reactive Power (Q)Apparent Power (S)Power FactorPhasor GroupComplex Phasor GroupSequence ComponentsZero SequencePositive SequenceNegative SequencePhasor Pair GroupThree Phase Complex PowerThree Phase Real PowerThree Phase Reactive PowerThree Phase Apparent PowerThree Phase Power FactorNotesFor users of conduit v0.0.8 or earlier, a framework for dataflow-style python programming, the versions are still maintained here. Starting with version 1.0 the new conduit package is a power engineering analytics library that also has dataflow-like properties. We would like to say a special thank you to@sleibmanfor allowing us to take over this namespace for our project!
Package: conduktor-public-api-client
conduktor-public-api-clientA client library for accessing Conduktor Public API
Generated withopenapi-python-client generate --path docs.yamlUsageFirst, create a client:fromconduktor_public_api_clientimportAuthenticatedClientclient=AuthenticatedClient(base_url="https://api.example.com",token="SuperSecretToken")Things to know:Every path/method combo becomes a Python module with four functions:sync: Blocking request that returns parsed data (if successful) orNonesync_detailed: Blocking request that always returns aRequest, optionally withparsedset if the request was successful.asyncio: Likesyncbut async instead of blockingasyncio_detailed: Likesync_detailedbut async instead of blockingAll path/query params, and bodies become method arguments.If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)Any endpoint which did not have a tag will be inconduktor_public_api_client.api.defaultAdvanced customizationsThere are more settings on the generatedClientclass which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlyinghttpx.Clientorhttpx.AsyncClient(depending on your use-case):fromconduktor_public_api_clientimportClientdeflog_request(request):print(f"Request event hook:{request.method}{request.url}- Waiting for response")deflog_response(response):request=response.requestprint(f"Response event hook:{request.method}{request.url}- Status{response.status_code}")client=Client(base_url="https://api.example.com",httpx_args={"event_hooks":{"request":[log_request],"response":[log_response]}},)# Or get the underlying httpx client to modify directly with client.get_httpx_client() or client.get_async_httpx_client()You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):importhttpxfromconduktor_public_api_clientimportClientclient=Client(base_url="https://api.example.com",)# Note that base_url needs to be re-set, as would any shared cookies, headers, etc.client.set_httpx_client(httpx.Client(base_url="https://api.example.com",proxies="http://localhost:8030"))
Package: condynsate
condynsatecondynsateis a dynamic system simulation and visualization tool built withPyBulletandMeshCat. It automatically simulates multiple objects and their interactions as described by.urdf,.stl, and.objfiles and can render real time visualizations in a web browser.InstallationFrom Sourcecondynsate requires python => 3.8pipinstallcondynsateMinicondaInstall MinicondaInstall Miniconda.To verify that Miniconda is installed properly, openAnaconda Prompt (Miniconda3)and run the command:conda--versionCreate a new virtual environmentTo create a new environment, openAnaconda Prompt (Miniconda3)and run the command:condacreate-nENVNAMENext, activate the newly made environment:condaactivateENVNAMEYou can confirm the virtual environment is activated when environment name on the left side of the command line changes from(base)to(ENVNAME)Install dependencies from Conda-Forge:Configure the environment channels by running the commands:condaconfig--env--addchannelsconda-forge
condaconfig--env--setchannel_prioritystrict
condaclean-a-iInstall dependencies available from Conda-Forge by running the command:condainstall-ypython=3numpypynputmatplotlibpybulletcontrolsympynotebookInstall condynsate using pipTo install condynsate run the commands:pipcachepurge
pipinstallcondynsateYou can ensure condynsate installed correctly by starting a python bash, importing condynsate, and checking the version number:pythonimportcondynsatecondynsate.__version__UsageFor examples of usage, seeexamples.
Package: cone
CONEconeis a tool to simplify your workflow when you are working on Roblox. It comes it two parts:A python package namedconeA Roblox plugin also namedcone-pluginconeis similar to any syncing tool for Roblox (likeRojo). What makesconeallows you to work outside of Roblox Studio, run your tests withTestEZfrom your command line.InstallationPackageIf you don't have python installed on your computer, you canget it here. Then, you can install the package by runningpip install conein your command line.PluginEasiest way to download it is from theRoblox pageHow to useconeConfiguration fileIn your working directory, there must be a file namedcone.jsonwhere you can tellconehow to sync your project.[
    {
        "path" : "src/ClientScripts",
        "parent" : "ReplicatedFirst"
    },
    ...
    {
        "path" : "src/ServerScripts",
        "parent" : "ServerScriptService"
    }
]Thepathkey needs to point to a folder or a file in your project. Theparentvalue needs to point to an instance in the Roblox place where you will parent the file or folder pointed bypath. You can place as many as you need.CommandsEach of these commands can be run in the working directory where youcone.jsonfile is located.cone testRuns your tests and prints the results in the console.cone deploy [-t]Takes you project and use thecone.jsonconfiguration file to apply your scripts in the opened Roblox place.cone revertReverts the last executedcone deploy.
Package: conebeam-projector
conebeam_projectorThis is theCONRADcone beam projector ported to pycuda.Installpipinstallconebeam-projectorOr from this repo:pipinstall-e.Usageimportpyconrad.autoinitimportpyconrad.configimportpycuda.gpuarrayasgpuarrayimportconebeam_projectorfromedu.stanford.rsl.conrad.phantomimportNumericalSheppLogan3Dphantom=np.array(NumericalSheppLogan3D(*pyconrad.config.get_reco_size()).getNumericalSheppLoganPhantom(),np.float32)pyconrad.imshow(phantom,"phantom")projector=conebeam_projector.CudaProjector()sino=gpuarray.zeros(pyconrad.config.get_sino_shape(),np.float32)projector.forward_project_cuda_raybased(phantom,sino,use_maximum_intensity_projection=False)pyconrad.imshow(sino,"Sinogram")backprojection=projector.backProjectPixelDrivenCuda(sino)pyconrad.imshow(backprojection,"backprojection")ConfigurationConfiguration of the projector geometry is done by (py)CONRAD.
The first time you use it CONRAD will suggest you to create a globalConrad.xmlin your home directory which stores all configuration options.
You can launchconradfrom bash command line to get a GUI loaded.
You can set the configuration programmatically viaimportpyconrad.autoinit# launches JVMimportpyconrad.configthis_is_the_configuration_obj=pyconrad.config.get_conf()This will give you a instance of CONRAD’sedu.stanford.rsl.conrad.utils.Configurationclass.
Package: conec
Context Encoders (ConEc)With this code you can train and evaluate Context Encoders (ConEc), an extension of word2vec, which can learn word embeddings from large corpora and create out-of-vocabulary embeddings on the spot as well as distinguish between multiple meanings of words based on their local contexts.
For further details on the model and experiments please refer to thepaper- and of course if any of this code was helpful for your research, please consider citing it:@inproceedings{horn2017conecRepL4NLP,
      author       = {Horn, Franziska},
      title        = {Context encoders as a simple but powerful extension of word2vec},
      booktitle    = {Proceedings of the 2nd Workshop on Representation Learning for NLP},
      year         = {2017},
      organization = {Association for Computational Linguistics},
      pages        = {10--14}
    }The code is intended for research purposes. It should run with Python 2.7 and 3 versions - no guarantees on this though (open an issue if you find a bug, please)!installationYou either download the code from here and include the conec folder in your$PYTHONPATHor install (the library components only) via pip:$ pip install conecconec library componentsdependencies:numpy, scipyword2vec.py: code to train a standard word2vec model, adapted from the correspondinggensimimplementation.context2vec.py: code to build a sparse context matrix from a large collection of texts; this context matrix can then be multiplied with the corresponding word2vec embeddings to give the context encoder embeddings:# get the text for trainingsentences=Text8Corpus('data/text8')# train the word2vec modelw2v_model=word2vec.Word2Vec(sentences,mtype='cbow',hs=0,neg=13,vector_size=200,seed=3)# get the global context matrix for the textcontext_model=context2vec.ContextModel(sentences,min_count=w2v_model.min_count,window=w2v_model.window,wordlist=w2v_model.wv.index2word)context_mat=context_model.get_context_matrix(fill_diag=False,norm='max')# multiply the context matrix with the (length normalized) word2vec embeddings# to get the context encoder (ConEc) embeddingsconec_emb=context_mat.dot(w2v_model.wv.vectors_norm)# renormalize so the word embeddings have unit length againconec_emb=conec_emb/np.array([np.linalg.norm(conec_emb,axis=1)]).Texamplesadditional dependencies:sklearntest_analogy.pyandtest_ner.pycontain the code to replicate the analogy and named entity recognition (NER) experiments discussed in the aforementioned paper.To run the analogy experiment, it is assumed that thetext8 corpusor1-billion corpusas well as theanalogy questionsare in a data directory.To run the named entity recognition experiment, it is assumed that the correspondingtraining and test filesare located in the data/conll2003 directory.If you have any questions please don't hesitate to send me anemailand of course if you should find any bugs or want to contribute other improvements, pull requests are very welcome!
Package: conectividadeapp
ConectividadeAppTable of ContentsSobre o ProjetoConstruído comPrimeiros PassosPré-requisitosInstalaçãoComo UsarLicençaContatoConhecimentoOutros ItensPágina de Administração do DjangoDiagrama Entidade RelacionamentoBPMNSobre o ProjetoUm plugin de Conectividade para o Netbox que permite manter o histórico de movimentação de ativos de TI (atividades de instalação e remoção).Construído comPythonDjangoBootstrapPrimeiros Passos:memo: Pré-requisitosNetbox v2.10.0+:wrench: Instalaçãopip install conectividadeapp==1.1.1Como UsarLicençaDistribuído sob a licença Apache 2.0. VejaLICENSEpara mais informações.ContatoConhecimentoOutros ItensPágina de Administração do DjangoDiagrama Entidade RelacionamentoBPMN