Saravanan666/pypi-org huggingface dataset:
Package: ceramatch
CeraMatchVisual shape-matching and classification of ceramicsCreated on 18. 5. 2019Table of ContentsAbout CeraMatchInstallationVideo GuideSample DataGenerating DatasetsContactAcknowledgementsLicenseAbout CeraMatchA graphical user interface to aDepositdatabase of digitized ceramic fragments created using theLaser Aided Profilercontrol application which implements automated ceramic shape matching and clustering as described inDemján et al. 2022.It has three basic functions: calculate (dis)similarity between samples; perform automatic clustering; and, allow users to rearrange clusters freely until they represent a valid classification. Furthermore, CeraMatch quantifies the degree of similarity of each fragment to a certain class, allowing for a probabilistic approach to classification, in which each vessel profile has quantifiable probabilities of belonging to particular classes or sub-classes. The application uses a hierarchical cluster analysis algorithm to assign each fragment into a cluster of similar specimens, a prerequisite for classification.For an in-depth description of the concepts behind CeraMatch see:DEMJÁN, P. - PAVÚK, P. - ROOSEVELT, CH. H. 2022: Laser-Aided Profile Measurement and Cluster Analysis of Ceramic Shapes. Journal of Field Archaeology 47 (8).https://doi.org/10.1080/00934690.2022.2128549InstallationFor a Windows installer see:https://github.com/demjanp/ceramatch/releases/latestTo install the latest version of Ceramatch as a Python module use:pip install ceramatchTo start the GUI execute:bin\start_cm.pyVideo Guide:Sample Data:Demján, P., Pavúk, P., Kaner, T., Bobik, J., & Roosevelt, C. H. (2021, October 15). Sample Data - Middle- to Late Bronze Age pottery from Kaymakçı.https://doi.org/10.17605/OSF.IO/UX8VDGenerating Datasets:You can create digital ceramics drawings usable in CeraMatch using theLaser Aided Profiler Control Applicationby digitizing pottery fragments directly using the LAP device, or by digitizing drawings in PDF or raster image format (see thisvideo guide).Contact:Peter Demján (peter.demjan@gmail.com)Institute of Archaeology of the Czech Academy of Sciences, Prague, v.v.i.AcknowledgementsDevelopment of this software was supported by OP RDE, MEYS, under the project "Ultra-trace isotope research in social and environmental studies using accelerator mass spectrometry", Reg. No. CZ.02.1.01/0.0/0.0/16_019/0000728.This software uses the following open source packages:cryptographyDeposit GUIDepositGraphvizlap_datanatsortNetworKitNetworkXNumPyOpenCV on WheelsOpenCVopenpyxlPillowPsycopgPyGraphvizPyShpPySide2Qtscikit-imagescikit-learnSciPyShapelysvgelementsUnidecodevalidatorsLicenseThis code is licensed under theGNU GENERAL PUBLIC LICENSE- see theLICENSEfile for details
Package: ceramic-py
Python client for ceramicA simple Ceramic Network client written in Python.This Ceramic client implements the payload building, encoding and signing needed to interact with theCeramic Network.Run the exampleThe example in this repository creates a new stream in a remote Ceramic node. This stream is initialized with the following data:{"hello": "world"}. It then retrieves the data, submits an update request to change that data to{"foo": "baz"}and retrieves the data again to prove that the update was successful.Note: the Ceramic node used in this examples should be used for testing purposes only. All the data pinned to that node is wiped periodically.Installpipenv.Generate the virtual environment:make new_envRun the example:python example.pyYou should see an output similar to the following:Created stream kjzl6cwe1jw147sv2ak3kksfgs14gc3jgjhu3mfnwn534l89joxi2tulv0ci14k
Current data is {'hello': 'world'}
Updated stream kjzl6cwe1jw147sv2ak3kksfgs14gc3jgjhu3mfnwn534l89joxi2tulv0ci14k
Current data is {'foo': 'baz'}
Package: cerastes
[![pypi](https://badge.fury.io/py/cerastes.svg)](https://badge.fury.io/py/cerastes)Cerastes==================================Cerastes is a pure python Client and library for Hadoop Yarn. The client uses RPC protobuf for communicating with Yarn services and provides a convinient python API for performing administration tasks on Yarn.Functionalities--------* Implement ResourceManager Administration Protocol* Implement ResourceManager Application Management Protocol* Implement HistoryServer Applications monitoring Protocol* Support both secure (Kerberos,Token) and insecure clusters* Supports HA cluster and implements HA ResourceManager Administration Tasks* Command line interface to interactively interact with YARN RCP apis on a python shell.* Works on Hadoop 2.0.0, tested mainly against CDH 5.xGetting started---------------Cerastes releases are available through pypi at <https://pypi.python.org/pypi/cerastes/>To install simply run:```bash$ pip install cerastes```USAGE-------Cerastes provides different Clients depending on the PRC Endpoint to communicate with, currently the supported client types are:* YarnAdminClient : Yarn Resource Manager administration client (non HA).* YarnHARMClient : Yarn Resource Manager HA administration client, this client only implements the HAService protocol and is limited to one Ressource Manager.* YarnAdminHAClient: Yarn Resource Manager HA administration client, this client implements all yarn RM administration tasks and HA tasks (like failover).* YarnRMApplicationClient: Yarn Resource Manager Application protocol, perform yarn applications management tasks.Currently the interactive python shell client is the easiest way to use cerastes:```python>>> import cerastes.client as client>>> RMCLIENT = client.YarnAdminClient(host="nn.hadoop.localdomain", port= 8033, use_sasl=True, yarn_rm_principal="yarn@HADOOP.LOCALDOMAIN", version=9)>>> RMCLIENT.get_groups_for_user("yassine.azzouz")>>> RMCLIENT.add_to_cluster_node_labels('test')>>>>>> HACLIENT = client.YarnAdminHAClient([{'host': "nn.hadoop.localdomain", 'port': 8033},{'host': "nn02.hadoop.localdomain", 'port': 8033}], use_sasl=True, yarn_rm_principal="yarn@HADOOP.LOCALDOMAIN", version=9)>>> HACLIENT.explicit_failover(force=True)True>>>>>> CLIENT = client.YarnHAAdminClient(host="nn.hadoop.localdomain", port=8033, use_sasl=True, yarn_rm_principal="yarn/nn.hadoop.localdomain@HADOOP.LOCALDOMAIN", version=9)>>> CLIENT.get_service_status(){'state': 'ACTIVE', 'readyToBecomeActive': True}>>>>>> APPCLIENT = client.YarnRMApplicationClient([{'host': "nn.hadoop.localdomain", 'port': 8032}], use_sasl=True, yarn_rm_principal="yarn/nn.hadoop.localdomain@HADOOP.LOCALDOMAIN", version=9)>>> APPCLIENT.get_applications()```Contributing------------I'd love to hear what you think about cerastes and appreciate any idea or suggestion, Pull requests are also very welcome!
Package: cerasus
CerasusCerasus is a simple dispatcher and quickstart function for ASGI apps based on Hypercorn
with Request/Response objects from Starlette.The dispatcher uses a mapping like this:{'GET':{'':webapp.index,'/':webapp.index,'/items/get':webapp.api.items.get},'POST':{'/items/add':webapp.api.items.add}}No REST. No Routes. What can be simpler?The mapping is constructed byexposedecorators. Here's an example that matches the mapping above:fromcerasusimportexpose,quickstartfromstarlette.requestsimportRequestfromstarlette.responsesimportHTMLResponse,JSONResponseclassAPIError(Exception):def__init__(self,status_code,description):self.status_code=status_codeself.description=descriptionclassItems:@exposeasyncdefget(self,request):items=[]# get items# ...returnJSONResponse(dict(status='success',items=items))@expose(methods='POST')asyncdefadd(self,request):item=awaitrequest.json()# add item# ...returnJSONResponse(dict(status='success'))classApi:# Customized error handling for API.# Error handlers can be either coroutines that return Starlette Response objects, or just objects:_undefined_method=JSONResponse(dict(status='error',description='Method not allowed'),status_code=405)_undefined_handler=JSONResponse(dict(status='error',description='Bad endpoint'),status_code=404)asyncdef_exception_handler(self,request,exc):returnJSONResponse(dict(status='error',description=exc.description),status_code=exc.status_code)# Note that children "inherit" error responses, i.e. we do not define them for Itemsitems=Items()classWebapp:api=Api()@expose(name='/')asyncdefindex(self,request):returnHTMLResponse('<h1>Hello</h1>')asyncdefopen_db():passasyncdefclose_db():passif__name__=="__main__":quickstart(Api(),{'bind':['127.0.0.1:12345']'alpn_protocols':['h2']},base_urlpath='/',on_startup=open_db,on_shutdown=close_db)
Package: cerbapi
A Python wrapper for the Cerb.ai API.UsageEnable the API and generate an API key-pair using the instructions
provided by Cerb.ai:https://cerb.ai/guides/api/configure-plugin/In your python environment, install cerbapi:pipinstallcerbapiIn your python project import and create a Cerb instancefromcerbapiimportCerbcerb=Cerb(access_key='myaccesskey',secret='IdeallyDontStoreThisInYourCodeLikeThis',base='https://example.com/index.php/base/')print(cerb.get_record('ticket',1))print(cerb.get_contexts())print(cerb.search_records('comment',query='author.worker:Rob'))For details on interacting with the API visit the website:https://cerb.ai/docs/api/
Package: cerber
A straightforward command line tool for generate seccomp json profileOverviewSeccomp (short for secure computing mode) is a computer security
facility in the Linux kernel.
Seccomp allows a process to make a one-way transition into a “secure”
state where it cannot make any system calls except exit(),
sigreturn(), read() and write() to already-open file descriptors.
Should it attempt any other system calls, the kernel will terminate
the process with SIGKILL or SIGSYS.
In this sense, it does not virtualize the system’s resources but isolates
the process from them entirely.Seccomp profile is used with by a lot of applications like:dockerfirefoxsystemdopensshchromeand more…Cerber help you to generate seccomp profile that you can
use with docker per example.PrerequisitesLinuxPython3.5+StraceInstall$pipinstallcerberUsageGenerate a seccomp_profile.json in your current directory:$cerberdockerrunhello-world$lsseccomp_profile.json$catseccomp_profile.json{"defaultAction":"SCMP_ACT_ERRNO","architecture":["SCMP_ARCH_X86_64","SCMP_ARCH_X86","SCMP_ARCH_X32"],"syscalls":[{"action":"SCMP_ACT_ALLOW","args":[],"name":"read"},...{"action":"SCMP_ACT_ALLOW","args":[],"name":"execve"},{"action":"SCMP_ACT_ALLOW","args":[],"name":"arch_prctl"}]}Now you can assign this seccomp profile to your container at run:$dockerrun\--rm\--security-opt="no-new-privileges"\--security-optseccomp=seccomp_profile.json\hello-world# you can get the following output for docker hello worldHellofromDocker!Thismessageshowsthatyourinstallationappearstobeworkingcorrectly.Togeneratethismessage,Dockertookthefollowingsteps:1.TheDockerclientcontactedtheDockerdaemon....Formoreexamplesandideas,visit:https://docs.docker.com/engine/userguide/Becareful to generate seccomp profile with cerber on the same cpu architecture
that your production environment (where you want run your container).Featuresdetect syscallsgenerate seccomp profile from detected syscallsContribute$gitclonehttps://github.com/gr0und-s3ct0r/cerber$cdcerber$pipenvinstallpbr$pipenvshell# generate a virtual environment$pythonsetup.pydevelop# install cerber in development mode$pipinstall-e.[test]# install testing dependencies$# make your changes$toxFurther readingsdocker security seccomp documentationdocker seccomp json formatdocker no new privileges security flagOriginal AuthorsSébastien Boyron (dj4ngo)Hervé Beraud (4383)CHANGES0.2.0install from pypifix license classifierupdate changelog0.1.0adding build badgefix pep8 errorsignore pycfix pep8 errorsadding overview about seccompadding further readingsexample on how to use security profilfix filename output on documentationfix installfix contribute guideupdate usage with seccomp.json file generateduse restructuredText for readme instead of markdownpackaging + TU + CIintroduce CIkeep strace statisticsadd gitignorerename tmpfile and create seccomp profile in a filedo not touch stdout and stderr to be transparent on executionfurther reading and contributorsupdate doc with commandpass command to execute to bouncerimprove usagerename toolinitialize repositoryHervé Beraud <herveberaud.pro@gmail.com>
Sebastien Boyron <sebastien@boyron.eu>
Package: cerbernetix.toolbox
py-toolboxpy-toolboxis a set of utilities for Python projectsRequirementsInstallationUsageDevelopmentCode styleTestingDocumentLicenseRequirementsThe toolbox has been written inPython 3, and it needs version3.7.The dependencies are managed bypipusing the filerequirements.txt.InstallationTo addpy-toolboxto your project, run the following command. This will add the last released version to you project:pipinstall--upgradecerbernetix.toolboxFor getting the last unstable version, the package needs to be installed from the source code. The following command will grab the last develop version:pipinstall--upgradegit+https://github.com/cerbernetix/py-toolbox.git@developIf you prefer using ssh:pipinstall--upgradegit+ssh://git@github.com/cerbernetix/py-toolbox.git@developUsagepy-toolboxoffers several utilities per domain.Please refer to thedocumentationfor more information.DevelopmentCheck out the repository:gitclonegit@github.com:cerbernetix/py-toolbox.gitThen, create the virtual env and install the dependencies:cdpy-toolbox
python3-mvenv".venv"source"./venv/bin/activate"pipinstall-rrequirements.txt
pipinstall-e.Note:For deactivating the virtual env, call the commanddeactivate.Automating the environment activation/deactivationFor activating the virtual env automatically when entering the project folder, and deactivating it when leaving the folder, you can add this snippet to you shell profile:cd(){builtincd"$@"localvenv=".venv"# If a Python virtualenv is active, deactivate it if the new folder is outsideif[[-vVIRTUAL_ENV]];thenlocalparent=$(dirname"${VIRTUAL_ENV}")if[["${PWD}"/!="${parent}"/*]];thendeactivatefifi# If a Python env folder is found then activate the virtualenvif[[-d"./${venv}"]];then# Is it a Python venv?if[[-f"./${venv}/bin/activate"]];thensource"./${venv}/bin/activate"fifi}Code styleCode is linted usingPyLintand formatted usingBlack. The docstrings are validated usingpydocstyle.TestingEach module comes with unit tests, by convention, atestfolder must be added to each packageUnit tests are made usingunittest. To run them:python3-munittestDocumentDocstrings are written following theGoogle docstrings format.The documentation is generated usinglazydocs.The script./pydoc.shcan be used to regenerate it.LicenseCopyright (c) 2023 Jean-Sébastien CONAN
Distributed under the MIT License (See LICENSE file or copy athttp://opensource.org/licenses/MIT).
Package: cerberus-api-client
Cerberus API ClientA Python package to scrape OpenShift/Kubernetes cluster failures stored in SQLite database. It can be used with theCerberustool.Submodulescerberus_api_client.client.custom_query_loopback modulecustom_query_loopback(database, loopback=60, issue="", name="", component="")Retrieve the failures satisfying the criteria specified by parameters in the pastloopbackminutes in the json format.Parameters:database: (str) Path where cerberus database is stored.loopback: (int) Time in minutes.issue: (list) A list of issue types.name: (list) A list of component names (e.g. pod names, node names).component: (list) A list of component types.cerberus_api_client.client.custom_query_interval modulecustom_query_interval(database, start_time="", finish_time="", issue="", name="", component="")Retrieve the failures betweenstart_timeandfinish_timethat satisfy the criteria specified by parameters in the json format.Parameters:database: (str) Path where cerberus database is stored.start_time: (timestamp) Timestamp in%Y-%m-%d %H:%M:%Sformat.finish_time: (timestamp) Timestamp in%Y-%m-%d %H:%M:%Sformat.issue: (list) A list of issue types.name: (list) A list of component names (e.g. pod names, node names).component: (list) A list of component types.
Package: cerberus-collections
Cerberusis a lightweight and extensible data validation library for Python.Here are the extensions.ContentsThis package aims to provide various code pieces that add functionality for
validations.Python 2 is not supposed to be supported, though some parts may run reliably.Error Handlerscerberus_collections.JSONErrorHandlercerberus_collections.XMLErrorHandler(requireslxml)(documentation)TODOHumanErrorhandlerYAMLloggerhandler chainerRulesTypesTODOpython builtin types (https://github.com/nicolaiarocci/cerberus/issues/186)common networking and posix dataValidatorsTODOPyObjectValidatorVersioning schemeThe first version segment of a release matches the one of the Cerberus version
it supports. The following parts reflect the release’s month and possibly pre-
or post-release segments.ContributingIf you have a Docker client installed, you can easily run all tests:<project_dir>/run-docker-testsTODOtype annotationsmaybe Cython
Package: cerberus-package-1
# borrow many code from:https://github.com/deepinsight/insightface/tree/master/detection/scrfd## How to install:pip install cerberuspackage## code python:``
from cerberuspackage import SCRFD
detector = SCRFD(“your onnx model”)#bboxes: [top_left_x, top_left_y, bottom_right_x, bottom_right_y],
#kpss: corrdinate 5 point on the face (left_eye, right_eye, nose, left_lip, right_lip)bboxes, kpss = detector(img)
#your postprocess with data predict by dcrfd
``
Package: cerbo
CerboCerbo means "brain" in Esperanto.It is a high-level API wrapping Scikit-Learn, Tensorflow, and TensorFlow-Keras that allows for efficient machine learning and deep learning modelling and data preprocessing while enjoying large layers of abstraction. Cerbo was originally developed to help teach students the fundamental elements of machine learning and deep learning without requiring prerequisite knowledge in Python. It also allows students to train machine learning and deep learning models easily as there is in-built error proofing.InstallThere are two simple ways of installing Cerbo.First, you can try:pip install cerboorpython -m pip install cerboIt is important to note that there are several packages that must already be installed to install Cerbo. The full list and versions can be found in requirements.txt, and nearly all can simply be installed through pip. If you are having trouble installing any of the prerequisite packages, a quick Google search and online coding forums such as StackOverFlow should explain how to install them correctly.Writing your first program!Currently, Cerbo performs efficient ML/DL modelling in a couple lines with limited preprocessing capabilites, we are adding new ones daily. Currently, to train a model from a CSV file all you have to do is callimportcerbo.preprocessingascpimportcerbo.MLascmldata,col_names=cp.load_custom_data("path_to_csv","column_you_want_to_predict",num_features=4,id=False)datais a dictionary containing X and y values, for training.col_namesis a list of featuresNote: set id to true when there is an Id column in the CSV File, and set Num_Features to any value(as long it is within the # of colunns in the file"After running this you will get 2 .png files labelled correlation, and features respectively.correlation.pngWill show a correlation matrix of all of the features in the CSV filefeature.pngWill show a Pandas Scatter Matrix of with a N x N grid with N beingnum_features.To train a model on this data just dogb=cml.Boosting(task="r",data=data,algo="gb",seed=42)cml.save_model(gb)Which quickly trains and saves a Gradient Boosting Regressor on this data.You can also dodt=cml.DecisionTree(task="c",data=data,seed=42)cml.save_model(dt)To train and save a quick Decision Tree Classifier.
Package: cerc-geometry
CERC Geometry LibraryThis project is a library with geometry classes with functions built purposely to manipulate geometry representation
of buildings. It has the following classes:Plane: has various methods that models a flat surface with no thicknessPoint: contains different methods to manipulate points in 2 and 3 dimensional spacesPolygon: contains methods to manipulate different kinds of polygonsPolyhedron contains a set of methods that manipulate three-dimensional shape with flat polygonal faces
Package: cereal-py
cerealParallelization requires tools to reference data without overuse of memory. cereal allows you to reference PyObjects to pointers without creating a deep copy in memory. An extension forZeroIntensity'spointers.py.cereal:DocumentationRepositoryPyPIpointers.py:AuthorDocumentationRepositoryPyPIimportnumpyasnpfromcerealimporteatx=[1,2,3,4]yum=eat(x,its=4,np.array,copy=False)>>yum>>array([<pointertolistobjectat0x113b3edc0>,<pointertolistobjectat0x113b3edc0>,<pointertolistobjectat0x113b3edc0>,<pointertolistobjectat0x113b3edc0>],dtype=object)# 4 pointers to the original object>>(~yum[0])[0]>>1yum[0][0]=4>>x# the original object>>[4,2,3,4]# it changed!
Package: cerealtest
CerealTest (WIP)This tool automates serial tests via a JSON configuration file where you specify port settings and the array of tests that will be run.You can specify the message to send as text or as hexadecimal data,  expected answer via a regular expression, or you can set a Python script to compute the message to send as well as a reception script that can process the answer for maximum flexibility.ContributionsThis repository is open to contributions, however code must be compatible with Python 3.8, the latest version that runs on Windows 7.
Package: cerebellum-value-map
Cerebellum Value MapThis package can show values as colors on top of a cerebellum illustration:It is used in the paperLongitudinal analysis of regional cerebellum volumes during normal aging.InstallInstall from GitHub:pipinstallgit+https://github.com/shuohan/cerebellum-value-mapInstall from PyPI:pipinstallcerebellum-value-mapUse the source code:gitclonehttps://github.com/shuohan/cerebellum-value-map# see https://docs.python.org/3/using/cmdline.html#envvar-PYTHONPATHexportPYTHONPATH=$(realpathcerebellum-value-map):$PYTHONPATHcdcerebellum-value-map/scripts./show_cerebellum.py-hSee thedocumentationfor more details.