Saravanan666/pypi-org huggingface dataset:
Package: calflate
Calflateis a command line application thatconflatesexternalCalDAVandCardDAVentries into an other online collection.
It does an one-way sync of calendar EVENTs, TODOs, JOURNALs and
addressbook entries (VCARD) based onUIDsandSEQUENCEorREVnumbers.Calflateis written in Python, it has no dependencies and
licenced under theFreeBSD License. The source code and
issue tracker is available athttps://github.com/chripo/calflate.Featuesone-way sync of VEVENT, VTODO, VJOURNAL and VCARDrewrite / cleanup UIDs based on regular expressionsimport entries from local files and online collectionsis able to purge destination itemssupports multiple collection setsconfigurable per collectionQuickstartInstall from source# create a virualenv
pip install https://github.com/chripo/calflate/zipball/master
ln -s $VIRTUAL_ENV/bin/calflate ~/bin/calflateConfigureCreate a configuration file  at~/.config/calflate.cfg. Insert
the following section for each collection that should be imported.[COLLECTION-NAME]
# ignore input argument from command line
# input = None

# never purge destination items
# purge = False

# verbose output
# verbose = True

# don't make changes
# dryrun = True

# replace UID pattern
# uid_from = (.+?)@foobar.com
# uid_to = \1

# source calendar / addressbook
src = https://source-host.net/test/events.ics/
# src_user = username
# src_pass = password

# destination calendar / addressbook
dst = https://my-server.net/user/calendar.ics/
dst_user = username
dst_pass = passwordExecutecalflate--helpto show usage.calflateCOLLECTION-NAMEto import a specific collection orcalflate '*'to conflate all sets.ContributionsAre welcome! Resepect PEP-8.
Package: calf-milp
CalfMilpCalfMilp is a binomial classifier that implements a course approximation linear function by mixed integer linear programming.ContactRolf Carlsonhrolfrc@gmail.comInstallUse pip to install calf-milp.pip installcalf-milpIntroductionCalfMilp provides classification and prediction for two classes, the binomial case.  Small problems are supported.  This is research code and a work in progress.CalfMilp is designed for use withscikit-learnpipelines and composite estimators.Examplefrom calf_milp import CalfMilp
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_splitMake a classification problemseed = 42
X, y = make_classification(
    n_samples=30,
    n_features=5,
    n_informative=2,
    n_redundant=2,
    n_classes=2,
    random_state=seed
)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=seed)Train the classifiercls = CalfMilp().fit(X_train, y_train)Get the score on unseen datacls.score(X_test, y_test)0.875
Package: calh
calhCalendar HeatmapInspired byvoila_spotify, to create a heatmap for calendar data.The app is available,at_heroku.You could also check out the notebook example,here.Free software: Apache Software License 2.0Documentation:https://calh.readthedocs.io.FeaturesFiltering calendarVisualizing calendarCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History2.2.0 (2020-05-13)Add UI with voila dashboard2.0.0 (2020-05-06)Input parameter refactored into input_data forHeatmapclass API.1.0.0 (2020-05-05)Support calendar filteringSupport calendar visualization as a heatmap0.1.2 (2020-03-06)Ensure tox passed0.1.1 (2020-03-06)Stop support on python 3.5 due to f-string0.1.0 (2020-03-06)First release on PyPI.
Package: calib
# pycaA python implemented certificate authority lib &amp; tools based on openssl## FeaturesVerify certificateGenerate root CASign server certificateSign client certificate## Future featuresMaintain certificate chainGenerate CRL (Certificate revocation lists)Generate OCSP (Online Certificate Status Protocol)## Simple usageBefore generating / signing anything, you have to init the key / certificate database.This is done by running commandpython -m calib –base [The database path] initPlease take care that any files or dirs will be removed in the database path. If the–baseargument is not given, the current working directory will be used.After initialized the database, you have to generate a root certificate by commandpython -m calib –base [The database path] createRootCertPlease usepython -m calib –helpfor more usage info.
Package: calib3d
Python camera calibration and projective geometry libraryThis library offers several tools for manipulation of calibrated cameras, projective geometry and computations using homogenous coordinates.Camera calibration allows to determine the relation between the camera's pixels (2D coordinates) and points in the real world
(3D coordinates). It implies computation using homogenous coordinates. This python library aims at simplifying implementations
of projective geometry computations, building on top ofnumpyandcv2.InstallationInstallation using the package manager pippipinstallcalib3dUsageFull API documentation is available inhere.2D and 3D points implementationThePoint2D(andPoint3D) class represent 2D (and 3D) points extendingnumpy.ndarray. Access to y coordinate ofpointispoint.y, and access to homogenous coordinates is made easy withpoint.H, while it is still possible to usepointwith anynumpyoperators.>>>Point2D(1,2)==Point2D(2,4,2)True>>>points=Point2D(np.array([[0,0,1,2,3],# x coordinates[1,2,3,4,5]]))# y coordinates>>>points.xarray([0.,0.,1.,2.,3.])>>>points.Harray([[0.,0.,1.,2.,3.],[1.,2.,3.,4.,5.],[1.,1.,1.,1.,1.]])Camera calibrationTheCalibclass represents a calibrated camera. It has a serie of methods to handle 3D to 2D projections, 2D to 3D liftings, image transformations, and more.>>>importnumpyasnp>>>fromcalib3dimportCalib,Point3D,compute_rotation_matrix>>>f=0.035# lens focal length [m]      35 mm lens>>>w,h=np.array([4000,3000])# sensor size       [px.px]  12 Mpx sensor>>>d=w/0.01# pixel density     [px.m⁻¹] with a 1 cm sensor width>>>K=np.array([[d*f,0,w/2],# Camera matrix (intrinsic parameters)...[0,d*f,h/2],...[0,0,1]])>>>C=Point3D(10,10,10)# Camera position in the 3D space>>>R=compute_rotation_matrix(Point3D(0,0,0),C)# Camera pointing towards origin>>>calib=Calib(K=K,T=-R@C,R=R,width=w,height=h)>>>calib.project_3D_to_2D(Point3D(0,0,0))Point2D([[2000.],[1500.]])Cropping or scaling a calib is made easy with the following operations (for more operations, check the documentation)>>>new_calib=calib.crop(x_slice=slice(10,110,None),y_slice=slice(500,600,None))>>>new_calib=calib.scale(output_width=2000,output_height=1500)Other useful methods>>>calib.projects_in(Point3D(0,20,20))False>>>calib.compute_length2D(Point3D(0,0,0),.42)# Number of pixels that represent a length of .42 in the 3D spacearray([339.48195828])ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.AuthorsThis library is developed and maintained byGabriel Van Zandycke. If you use this repository, please consider citing my work.
Package: calibcant
calibcant: tools for thermally calibrating AFM cantileversCalculates the spring constantkof a cantilever using the
equipartition theorem:1/2 k_B T = 1/2 K x^2The analysis uses the expected power spectral density (PSD) of a
damped simple harmonic oscillator to filter out noise from the
measured PSD.InstallationPackagesGentooI’ve packaged calibcant for Gentoo.  You needlaymanand mywtk
overlay.  Install with:# emerge -av app-portage/layman
# layman --add wtk
# emerge -av sci-physics/calibcantDependenciesIf you’re installing by hand or packaging calibcant for another
distribution, you’ll need the following dependencies:PackageDebianGentooNumpypython-numpydev-python/numpyScipypython-scipysci-libs/scipyH5configdev-python/h5config[1]H5Pypython-h5pydev-python/h5pyMatplotlibpython-matplotlibdev-python/matplotlibNosepython-nosedev-python/noseFFT_toolsdev-python/FFT-tools[1]Pypiezosci-libs/pypiezo[1][1](1,2,3)In thewtk overlay.You’ll also need mypyafmandstepperpackages, or suitable
replacements.Installing by handCalibcant is available as aGitrepository:$ git clone git://tremily.us/calibcant.gitSee thehomepagefor details.  To install the checkout, run the
standard:$ python setup.py installUsageSee the module docstrings for simple examples.TestingRun internal unit tests with:$ nosetests --with-doctest --doctest-tests calibcantLicenceThis project is distributed under theGNU General Public License
Version 3or greater.AuthorW. Trevor Kingwking@tremily.usCopyright 2007-2012
Package: calibpy
CalipyCalipy is a camera calibration and registration toolbox. It is based onOpenCVand implements an easy access to internal and  external camera calibration usingChArUco Boards. The external calibration routines are tested and guaranteed to be consistent with the Blender coordinate conventions.
MIT LicenseCopyright (c) [2022] [Dr. Sven Wanner & Ben Niehaus]Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: calibr8
calibr8This package provides templates and functions for performing likelihood-based calibration modeling.
To see implementation examples & excercises, you can go tonotebooks/.Installationcalibr8is released onPyPI:pip install calibr8DocumentationRead the package documentationhere.Usage and Citingcalibr8is licensed under theGNU Affero General Public License v3.0.When usingcalibr8in your work, please cite theHelleckes & Osthege et al. (2022) paperandthecorresponding software version.Note that the paper is a shared first co-authorship, which can be indicated by1in the bibliography.@article{calibr8Paper,doi={10.1371/journal.pcbi.1009223},author={Helleckes$^1$, Laura Marie andOsthege$^1$, Michael andWiechert, Wolfgang andvon Lieres, Eric andOldiges, Marco},journal={PLOS Computational Biology},publisher={Public Library of Science},title={Bayesian and calibration, process modeling and uncertainty quantification in biotechnology},year={2022},month={03},volume={18},url={https://doi.org/10.1371/journal.pcbi.1009223},pages={1-46},number={3}}@software{calibr8version,author={Michael Osthege andLaura Helleckes},title={JuBiotech/calibr8: v6.5.2},month=mar,year=2022,publisher={Zenodo},version={v6.5.2},doi={10.5281/zenodo.4127012},url={https://doi.org/10.5281/zenodo.4127012}}Head over to Zenodo togenerate a BibTeX citationfor the latest release.
Package: calibrate
This is a simple tool that constructs a calibration curve using known x
and y values from standards, and backout the x value for an unknown
based on its measured y signal.FeaturesGiven x and y, creates calibration curve and finds linear portion and
limits of linearityGiven y of an unknown, interpolates to find xComputes interpolation errorDevelopmentDevelopment requires Docker and Make on your host system. Everything else is taken care of inside the
Docker container.Spin up your container using the provideddocker-compose.ymlfile andMakefileby runningmake image. This creates an image with a correct git configuration for your user, which makes it
easy to release. All of the commands you should need to run are defined theMakefileas targets.
All of the targets except forimage, are meant to be run inside the Docker container, but can be
run from the host machine by having-extappended to them. For example, to run tests, you could
either callmake testfrom a shell inside the container, ormaketest-extfrom the host.Dependencies are managed through thecondatool and defined inenvironment.yml. All new dependencies must be specified with a version, for a reproducible build
environment.All pull requests are run through the Travis CI process specified in.travis.ymland must pass
all tests before being accepted.DeploymentDeployment of tagged commits happens to PyPI automatically via Travis CI. To bump and deploy a new
version directly, you must have access to write to the master branch. Runmakebump/[foo]-ext,
where[foo]ismajor,minor, orpatch. Thengit push origin--tagsmaster. If
you do not have access to the master branch, do the same thing, but in a separate branch, and make
a pull request.
Package: calibrated
Calibrated!This is a middleware for django which gives same structure in django success and error case.When frontend softwares integrate apis, then they expect response structure should remain same in case of both error and success. By adding this middleware onne can achive sam structure through out.{
"status":  false,
"detail":  {},
"error_detail":  {
}
}The above payload is the structure which one can recive by applying the package to django appliaction.Description to payloadstatus field can be true or false in success and error case respectivelydetail field will always be in form of dict and will hold value only in case of success(2xx)error_detail will have detail in cases excluding (2xx)Steps to installThis is quite easy to usepip install calibratedAfter installing pip package, go to you django settings and add middewarecalibrated.Response
Package: calibrate-receiver
Calibrate-multifeed-receiverDownloadThis project is written in Python3 (3.8), so make sure you have it installed in your machine.
After that you can download the repository, open terminal and type:gitclonehttps://github.com/LorenzoMonti/calibrate-multifeed-receiver.gitProject's dependeciessudoapt-getinstallpython3-tkcdcalibrate-multifeed-receiver/
python3setup.pyinstallInstallpython3setup.pyinstallUsageNow you can run the project:calibrate_multifeed_receiverLicenseMIT
Package: calibration-belt
Calibration BeltAssessment of the calibration belt and goodness of fit of binomial models.Installationpip install calibration-beltimportpandasaspdfrompathlibimportPathfromcalibrationimportCalibrationBeltimportmatplotlib.pyplotasplt%matplotlibinlineLoading datadf=pd.read_csv(Path('tests/data/example_data.csv'))# Separate P (outcome) and E (probability outputed by the model)# In this case we will evaluate two different modelsP=df.target.to_numpy()predictors={'SVM':df.SVM.to_numpy(),'NN':df.NN.to_numpy()}CalibrationBelt object# We create CalibrationBelt objects for# each model we want to evaluatebelts={}forkey,Einpredictors.items():belts[key]=CalibrationBelt(P,E)Plotting the belt# Calculate belt in the confidence intervals .8 and .95formodel,beltinbelts.items():fig,ax=belt.plot(confidences=[.8,.95])ax.set_title(model,fontsize=30)Calculating T-statistic and p_valueformodel,beltinbelts.items():T,p_value=belt.test()print(f"Model:{model:3}, T-statistic:{T:08.5f}, p-value:{p_value:07.5f}")Model: SVM, T-statistic: 08.37500 , p-value: 0.01518
Model: NN , T-statistic: 31.05418 , p-value: 0.00001Calculating boundaries of the beltboundaries=belt.calculate_boundaries(.95)lower,upper=boundaries[0,1:]print(f"Lower bound:{lower:.4f}, Upper bound:{upper:.4f}")Lower bound: 0.0000, Upper bound: 0.0493Cumulative distribution functionThe plot below shows the computed distribution of the T-statistic in polynomials of degree m.T=[i/10foriinrange(0,301)]viridis=plt.cm.get_cmap("viridis",4)fig,ax=plt.subplots(1,figsize=[10,7])formin[1,2,3,4]:cdf=[]fortinT:cdf.append(CalibrationBelt.calculate_cdf(t,m,.8))ax.plot(T,cdf,color=viridis(m-1))ReferencesBased onNattino, Giovanni, Stefano Finazzi, and Guido Bertolini. "A new calibration test and a reappraisal of the calibration belt for the assessment of prediction models based on dichotomous outcomes." Statistics in medicine 33.14 (2014): 2390-2407.
Package: calibration-manager
calibration_managerA simple, ROS installable OR pure python package for keeping track of configuration and calibration data.Calibrations are organized by machine setup, component, and time of the calibration in a file structure.
Thay may contain any standard python type, and will automatically load numpy arrays and pandas dataframes.A calibration is considered valid for a specific configuration, so a snapshot of the current cfg is stored in the calibration; this allows easy recall of a specific state for later analysis.Once created, calibrations can be loaded and accessed as a dictionary:import calibration_manager as cm

setup = cm.Setup('my_machine')
setup.save_example_cal()
components = setup.load()
pA = setup.cfg['example_component']['test_param_A']
cA = setup.cal['example_component']['test_cal_A']
arr = setup.cal['example_component']['test_array_B']Don't forget that you can unpack all the dict keys into a function variable directly:def func(test_param_A, test_array_B, **kwargs):
    return test_param_A + test_array_B

arr_B = func(**setup.cal['example_component'])To save a new calibration, just construct a dictionary of your parameters and pass to cal:my_np_array = np.random.rand(3,3)
my_calibration = {
    'A': 3.0,
    'B': True,
    'C': 'pinhole',
    'subsystem': {
        '1': my_np_array
    }
}
setup.save_component_cal('camera1', my_calibration)If ros is installed (optional!) and the code has connection to a roscore,
it can automatically upload parameters to the rosparam server.
If a ros_param_ns is provided in load(), all values in the cal.yaml will be loaded, or
if ros_param_ns is set to 'default', it will default to /{machine}/{component}/{params}.Setups are stored in ~/.ros/setups/ by default, but this can overwritten with:setup = cm.Setup('my_machine', '/my/setups/root/dir/')Future features planned:when instantiating a component for the first time when no default_cfg is available, run a prompt to get the user inputload from a SCOPS build folderallow datetime loadingSuggestions and commits are welcome.
Package: calibration-scores
Calibration Scores ModuleOverviewThis module is a work in progress method to assign a score to each sensor used at PBR events. The program takes input data from one event and compares each player's metrics to those that they achieved at past events. Each calibration is assigned a score from 0-1, with 1 being the most accurate score and 0 being completely inaccurate. Currently, the module supports scores for trackman pitching data and scores the calibrations based on extension, release height, and release width (relside). Further support will be added for blast data and swift 60 yard dash times.EnvironmentThis folder was set up in the poetry virtual environment. Poetry allows for dependencies to be added easily, with the commandpoetry add DEPENDENCY.DependenciesPython "^3.9"numpy = "^1.25.1"pandas = "^2.0.3"matplotlib = "^3.7.2"Data GatheringTo run these programs on your local machine with up to date data, you may query for in in AWS Athena. For instructions on gathering data and what queries to run, follow the below links to the notebook folder in this repository.
(Add links here once files are pushed to repo)UsageThis package will be integrated into the UI for event coordinators. After an event finishes, the coordinator will be able to see this information on their device and choose whether or not to send the event data in with or without a flag.All functions currently supported have their uses demonstrated in the calibration_scores_example.ipynb file located in the notebooks folder of this repository. Feel free to modify or add commands as you see fit for your workflow.ContributingContributions to this package are encouraged as it is not a finished product. Feel free to suggest changes to the code or testing files. Make sure to include a clear description of your changes in your pull request. Aditionally, for code to be pushed, it is required that one reviewer approves your changes.
Package: calibraxis
An Python/NumPy implementation of the accelerometer calibration method
described in[1]. This is a Python reimplementation of the
Matlab routine found at[2].Installation$pipinstallgit+git://github.com/hbldh/calibraxis.gitUsageimportnumpyasnpfromcalibraxisimportCalibraxisc=Calibraxis()points=np.array([[-4772.38754098,154.04459016,-204.39081967],[3525.0346179,-68.64924886,-34.54604833],[-658.17681729,-4137.60248854,-140.49377865],[-564.18562092,4200.29150327,-130.51895425],[-543.18289474,18.14736842,-4184.43026316],[-696.62532808,15.70209974,3910.20734908],[406.65271419,18.46827992,-4064.61085677],[559.45926413,-3989.69513798,-174.71879106],[597.22629169,-3655.54153041,-1662.83257031],[1519.02616089,-603.82472204,3290.58469588]])# Add points to calibration object's storage.c.add_points(points)# Run the calibration parameter optimization.c.calibrate_accelerometer()# Applying the calibration parameters to the calibration data.c.apply(points[0:])>>>(-0.9998374717802275,0.018413117166568103,-0.015581921828828033)c.batch_apply(points)>>>[(-0.9998374717802275,0.018413117166568103,-0.015581921828828033),(0.9992961622260429,-0.013214366898928225,0.02485664909901566),(-0.019529368790511807,-0.9999036558762957,-0.0016168646941819831),(0.02495705262007455,0.9997148237911497,0.002962712686085044),(0.01976766176204912,-0.004116860997835083,-0.9989226575863294),(-0.01861952448274546,-0.0030340053509653056,0.9994716286085392),(0.2486658848595297,-0.0015217968569550546,-0.9695063568748282),(0.2743240898265507,-0.9612564659612206,-0.01023892300189375),(0.2845586995260631,-0.8814105592109305,-0.37753891563574526),(0.5138552246439876,-0.14594841230046982,0.8459602354269684)]TestingRun tests with:$pythonsetup.pytestor withPytest:$py.testtests.pyDocumentationTBW.References[1]Frosio, I.; Pedersini, F.; Alberto Borghese, N.,
“Autocalibration of MEMS Accelerometers,” Instrumentation and Measurement,
IEEE Transactions on, vol.58, no.6, pp.2034,2041, June 2009[2]Matlab File Central.
Package: calibrestekje
Library prototyping based on CalibreCalibrestekje is a Python library which provides a way to work with theCalibredatabase outside the context of the Calibre desktop and web
interfaces.GeneratedSQLAlchemydatabase bindings (seesqlacodegenfor
more) are provided which allow for read/write access to an existing Calibre
database. These bindings are more fine grained than Calibresdatabase
interfaceand provide direct access to the Database table layer.Aflaskextension is also provided for getting started with web prototyping.
Please seeflask-calibrestekjeandthe flask usage documentationfor
more.Quick ExamplefromcalibrestekjeimportBook,Publisher,init_sessionsession=init_session("sqlite:///mymetadata.db")publisher=(session.query(Publisher).filter(Publisher.name=="MIT Press").one())books=(session.query(Book).filter(Book.publishers.contains(publisher)))print(f"Books published by MIT Press:{books.count()}")Documentationhttps://calibrestekje.readthedocs.io/Mirroringhack.decentral1.se/decentral1se/calibrestekje
Package: calibtools
This is a very incomplete set of tools for camera calibration.RequirementsOpenCV’s Python BindingsmoviepynumpyUsagePrint out a checkerboard and record a video of you waving it around. Thecalibtools-calibscript can then be used to estimate camera parameters. Thecalibtools-undistortscript will then undistort input videos based on the
parameters.InstallationThe easiest way to installcalibtoolsis viaeasy_installorpip:$ pip install calibtoolsIf you want to check out the latest in-development version, look atthe project’s GitHub page. Once checked out,
installation is based on setuptools and follows the usual conventions for a
Python project:$ python setup.py install(Although thedevelopcommand may be more useful if you intend to perform any
significant modification to the library.)Further documentationThere ismore documentationavailable online and you can build your own copy via the Sphinx documentation
system:$ python setup.py build_sphinxCompiled documentation may be found inbuild/docs/html/.