Saravanan666/pypi-org huggingface dataset:
Package: calibur
Calibur🗡️Calibur, a sword towards the many inconsistent and ambiguous conventions
(viewport origins, depth range, camera coordinate systems, etc.) in computer graphics and vision.It is a library that translates between these conventions for you.
It also hosts as a library of documentation of different conventions and space definitions in CG and CV
that would otherwise be hard to find.InstallationpipinstallcaliburDocumentationThe documentation is hostedhere.
Package: calico
Calico is a utility for checking command-line programs in terms of their
input and output. It checks whether a program generates the correct output
when given some inputs. It was developed to evaluate simple programming
assignments in an introductory programming course.Getting startedYou can install Calico using pip:pip install calicoCalico usespexpectfor interacting with the program it is checking.
The file that specifies the inputs and outputs for the checks
is inYAMLformat.Getting helpThe online documentation is available on:https://calico.readthedocs.io/The source code can be obtained from:https://github.com/itublg/calicoLicenseCopyright (C) 2016-2019 H. Turgut Uyar <uyar@itu.edu.tr>SeeAUTHORS.rstfor a list of all contributors.Calico is released under the GPL license, version 3 or later. Read
the includedLICENSE.txtfor details.
Package: calico-python
CalicoCalico is a lightweight visual-inertial calibration library that allows for rapid problem construction, debugging, and tool creation. Unlike other codebases that are limited to standalone calibration tools for specific hardware setups, Calico is a flexible library that enablesbuilding and modifying custom toolsto suit your hardware requirements. If your calibration problem aligns with our geometry paradigm, there is no need to modify the underlying optimization.Calico features:Flexible auto-differentiable cost functors.Sensor intrinsics, extrinsics, and latency estimation.The ability to add multiple sensors.Measurement outlier tagging and exclusion.Per-sensor robustifier kernels.Ability to create custom sensor models.Check out ourwiki pagesfor more info.LicensePoor sensor calibration is a problem endemic to robotics, yet it's typically not given enough attention because it tends to detract from higher level project goals. The purpose of this library is to help roboticists quickly resolve their calibration issues so that they can move on to more interesting things. This library is hereby granted the MIT license, to be used free of charge by anyone within academia or industry.To the best of my knowledge, all library dependencies also fall under BSD 2/3, LGPL, or Apache 2.0.MIT LicenseCopyright (c) 2023 James YangPermission 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: california-house-price-predictor-7606
Median housing value predictionThe housing data can be downloaded fromhttps://raw.githubusercontent.com/ageron/handson-ml/master/. The script has codes to download the data. We have modelled the median house value on given housing data.The following techniques have been used:Linear regressionDecision TreeRandom Forest with RandomizedSearchCVRandom Forest with GridSearchCVSteps performedWe prepare and clean the data. We check and impute for missing values.Features are generated and the variables are checked for correlation.Multiple sampling techinuqies are evaluated. The data set is split into train and test.All the above said modelling techniques are tried and evaluated.Mean squared error, Root mean squaerd error, Mean absolute error metrics are used to evaluate the modelTo excute the script'sThere are three scripts need to run for evaluating the model$ python ingest_data.py -p rawyou can run this script with specifying where you want to place the downloaded data and also with default arguments$ python train.py -x housing_prepared.csv -y housing_labes.csvyou can run this script with specifying dependent and independent variables and also with no argument passed$ python score.py -m final_model.pkl -d test_set.csvyou can run this script with specifying which ML model want to use and with what dataset to score metrics
Package: caliper
Caliper is a tool for measuring and assessing change in packages.See thedocumentationfor getting started.TODOwrite tests to discover and test all metrics (type, name, etc.)think of common functions to run metriccreate visualization of grid of errors / scripts, and mouesover to see codes (server rendered)stats: try to estimate types of codes (e.g., error name)Analysis IdeasStart with a bunch of unit tests for a library (or example scripts) and build a model that can predict success (return code 0) vs fail (any other code) based on the scripts (tokens is a simple idea). Then given a new script without declared versions, predict which will work.(A slightly different project) - given a set of known "optimal" containers for a library like tensorflow, parse dependencies, versions, and library versions, run across same set of unit tests / example scripts, and try to say which combos (architecture and dependencies) works for different kinds of scripts.LicenseFree software: MPL 2.0 License
Package: caliper-reader
caliper-reader: A Python reader for Caliper filesThis Python package reads the native .cali files produced by theCaliperperformance profiling
library.You can install caliper-reader with pip:$ pip install caliper-readerAlternatively, add thepython/caliper-readerpath in the cloned
Caliper repository toPYTHONPATH.UsageTheCaliperReaderclass reads a Caliper file and then provides its
contents in therecordsandglobalsclass members, whererecordsis a Python list-of-dicts containing the recorded performance data
andglobalsis a Python dict with program metadata about the run.
The dicts represent Caliper attribute:value records: the key is the
Caliper attribute name; the value is a string or list of strings.
The example below prints theavg#inclusive#sum#time.durationmetric
for every region path in the provided example profile data file:importcaliperreaderascrr=cr.CaliperReader()r.read('example-profile.cali')metric='avg#inclusive#sum#time.duration'forrecinr.records:path=rec['path']if'path'inrecelse'UNKNOWN'time=rec[metric]ifmetricinrecelse'0'if(isinstance(path,list)):path="/".join(path)print("{0}:{1}".format(path,time))The CaliperReaderattributes()function returns the list of Caliper
attributes. Theattribute()function returns anAttributeobject
to query metadata for a given Caliper attribute name:>>>a=r.attribute('avg#inclusive#sum#time.duration')>>>a.get('attribute.unit')'sec'You can use theread_caliper_contentsfunction as a shortcut to read
Caliper data without creating aCaliperReaderobject:(records,globals)=cr.read_caliper_contents('example-profile.cali')Useread_caliper_globalsif you only need the global (metadata) record:globals=cr.read_caliper_globals('example-profile.cali')AuthorsCaliper was created byDavid Boehme,boehme3@llnl.gov.ReleaseCaliper is released under a BSD 3-clause license.
SeeLICENSEfor details.LLNL-CODE-678900
Package: calistar
calistaris a tool to search for a single calibration star. For example to be used for reference-star differential imaging or aperture masking interferometry. The package has been released onPyPIand is actively developed and maintained on Github.DocumentationDocumentation can be found athttp://calistar.readthedocs.io.ContributingContributions are welcome so please considerforkingthe repository and creating apull request. Bug reports and feature requests can be provided by creating anissueon the Github page.LicenseCopyright 2023 Tomas Stolkercalistaris distributed under the MIT License. SeeLICENSEfor the terms and conditions.
Package: caliz
CALIZ CALCULATOR WITH Python UI-LIBA new, modern look is provided by CALIZ-Calculator, a Python calculator based on CustomTkinter, The code should be easy to understand for beginner programmers and accessible to the users. Element by element Customtkinter has been used for the program.
You can use the system appearance or the manually set mode ('light', 'dark'), whichever you prefer, and you'll get a consistent appearance, Windows, macOS, and Linux all have a fresh, modern look.InstallationInstall the module with pip:pip3 install calizUpdate existing installation:pip3 install caliz --upgrade(update as often as possible because this library is under active development)Use-HowTOAfter installingCALIZgo to python in terminal and import calculator from caliz library,
i.e. -->from caliz import calculatorand the calculator will be shown to you.If you need to get more info about CustomTkinter Go through theDocumentationprovided below,DocumentationTheofficialdocumentation for CustomTkinter can be found in the Wiki Tab here:-->Documentation.Thank You From MAS.
Package: calla
Pelican manager[![Build Status](https://travis-ci.org/xiaojieluo/pelican-manager.svg?branch=master)](https://travis-ci.org/xiaojieluo/pelican-manager)
[![codecov](https://codecov.io/gh/xiaojieluo/pelican-manager/branch/master/graph/badge.svg)](https://codecov.io/gh/xiaojieluo/pelican-manager)pelican_manager 运行目录为根目录, 配置文件中的目录都应该以此为 root.## 0.1 (2018-01-29)
- 第一版， 基本功能, 开发中。。
Package: callableabc
callableabcThis package implements a metaclass and convenience instance of it that works likeabc.ABC, but allows you to customize what happens when the class object gets called by implementing a_class_call()classmethod.Inherit from the convenience classCallableABCto get this behavior,
or use the metaclassCallableABCMetadirectly.The metaclass uses theCallableABCMetaDictdictionary subclass to keep track of the_class_call()method.
Package: callableExpressionParser
mathExpressionParserMath Expression Parser that works with [ + - * / ^ // ! ] operators, constants [ pi ], functions [ exp, log, ln ], strings ["testString"], and [variables] out of the box and can be expanded to cover more use cases!MotivationA lot of the math expression parsers I found online didn't quite cover all the use cases I needed as well as were hard to expand upon. With that, I created my own!How To Installpip install callableExpressionParserHow To UseRegardless of the language, you'll primarily use 2 lines of code in order.createExpressionTree - This function takes the list of nodes from extractNodes or an expression string and parses its nodes and creates a binary tree. Each parent node is an operator or a function, and each child node is a number, constant, or token group. This function returns the base node of the tree which you can call exec() on to prepare the tree.The result of the base Node's exec() function is a function that takes in an optional dictionary argument. If any variables are defined in the expression, the variables will be replaced with the dictionary key-value where the key is the variable's name.What's great about this approach is say you have a table represented as a list of dictionaries. If you'd want to add a calculated column that is some expression based on other row values, you can create the new column easily.Example in pythonfromcallableExpressionParserimportcreateExpressionTreetbl=[{'a':1,'b':2},{'a':3,'b':4},{'a':5,'b':6}]expression='[a]+2*[b]'func=createExpressionTree(expression=expression).exec()tbl=[{**r,'c':func(**r)}forrintbl]print(tbl)# [{'a': 1, 'b': 2, 'c': 5.0},{'a': 3, 'b': 4, 'c': 11.0},{'a': 5, 'b': 6, 'c': 17.0}]Print the Binary Tree ExpressionAfter an expression tree is created usingcreateExpressionTree()you can call thedisplay()function on the root node of the tree to see the Binary Tree printed out.Shoutout to thisStack Overflow Answerfor the code!fromcallableExpressionParserimportcreateExpressionTreeexpression='[a]+2*[b]'root=createExpressionTree(expression=expression)root.display()#  +_# /  \# a  *#   / \#   2 b
Package: callable-pip
callable-pipcallable-pipprovides a drop-in replacement forpip.main()and support
for monkey-patchingpip.mainvia a known-dangerous method.pip.main()has never been a publicly supported API forpip, but it has
often been used as such. This tiny package is meant to cover the gap and ease
people’s transitions to new usage.Drop-in Replacement for pip.mainThis usage isalways guaranteed to workon any supported python version with
any functioning version ofpip.Instead ofpip.main(...), use this method instead:import callable_pip
callable_pip.main('install', '--upgrade', 'setuptools')If you are writing a python program, you can just usecallable_pip.main()yourself. This is the only guaranteed-safe usage.Patching pip.maincallable-pipprovides a patch which addspip.main()back topip,
but which is dangerous and known not to work on some versions ofpip:import callable_pip
callable_pip.dangerous_patch()
...
import pip
pip.main('--version')  # actually invokes callable_pip.main()If you have dependencies which usepip.main, you can callcallable_pip.dangerous_patch()yourself and it willusuallywork.dangerous_patchis so-named because it isnotguaranteed to work on allpipversions and it is dangerous. Avoid it when possible.Patching Without Control of SourceYou may be a consumer of packages which usepip.main()in a context where
you cannot modify or do not own any of the source.
These techniques may help you.More details onsitecustomize.pyand.pthfiles can be found in the
Python documentation:https://docs.python.org/3/library/site.htmlRemember to remove these patches if you uninstallcallable_pip, or Python
will fail to start.Applying the Patch With sitecustomize.pysitecustomize.pycan exist anywhere in thePYTHONPATH, including the
directory where python is invoked.Add asitecustomize.pywith the following content, or append it to an
existingsitecustomize.py:import callable_pip
callable_pip.dangerous_patch()Applying the Patch With a .pth FileThe.pthfile can have any name you want, but must be installed in thesite-packagesdirectory. It may therefore require root or other elevated
privileges to add.Add a file, e.g.callable_pip.pth, with the following content:import callable_pip; callable_pip.dangerous_patch()DocumentationAll documentation is in this readme doc.Bug and Issue ReportsSubmit all bug reports and issues here:https://github.com/sirosen/callable-pip/issues
Package: callback-executor
Request SenderThis module provides aCallbackExecutorclass to receive and queue callbacks to
be executed in a configured interval between calls.The time between calls can be greater than the configured interval, but not less.Use CaseIf one needs to limit the rate of request to an API endpoint.Sample Codeimport asyncio
from callback_executor import ExecutorQueue

async main():
    exec_queue = ExecutorQueue(call_interval=0.5)
    await exec_queue.ready()
    
    tasks = [
        exec_queue.enqueue_callback(blocking_request_to_api_1),
        exec_queue.enqueue_callback(blocking_request_to_api_2),
    ]
    
    responses = await asyncio.gather(*tasks)
    
    # Handle responses

if __name__ == "__main__":
    asyncio.run(main())
Package: callbackin
callbackinUsage:$callbackin[OPTIONS]COMMAND[ARGS]...Options:--install-completion: Install completion for the current shell.--show-completion: Show completion for the current shell, to copy it or customize the installation.--help: Show this message and exit.Commands:createdeleteeditinitlistloginruncallbackin createUsage:$callbackincreate[OPTIONS]Options:--help: Show this message and exit.callbackin deleteUsage:$callbackindelete[OPTIONS]IDArguments:ID: ID of the callback to delete  [required]Options:--help: Show this message and exit.callbackin editUsage:$callbackinedit[OPTIONS]IDArguments:ID: ID of the callback to edit  [required]Options:--help: Show this message and exit.callbackin initUsage:$callbackininit[OPTIONS]Options:--help: Show this message and exit.callbackin listUsage:$callbackinlist[OPTIONS]Options:--help: Show this message and exit.callbackin loginUsage:$callbackinlogin[OPTIONS]Options:--help: Show this message and exit.callbackin runUsage:$callbackinrun[OPTIONS]IDArguments:ID: ID of the callback to run  [required]Options:--help: Show this message and exit.
Package: callback-lru-cache
We can use Python built-in functions.lru_cache, but when a cached item is evicted, there is no chance to release corresponding resources.This LRU Cache with callback feature provides the similar usage as functions.lru_cache with decorator@lru_cache. Plus, it can task aeviction_callbackfunction to do clean works. The function signature iscallback(key, value).Basic LRU Cache@lru_cache(3)deffetch(x):print('miss:',x,end='')returnx+1foriin[1,2,3,1,2,4,3,2,1]:print(f'get data for{i}: ',end='')fetch(i)print()Output:get data for 1: miss: 1
get data for 2: miss: 2
get data for 3: miss: 3
get data for 1:
get data for 2:
get data for 4: miss: 4
get data for 3: miss: 3
get data for 2:
get data for 1: miss: 1LRU Cache with callback for evictiondefeviction_callback(key,value):# release resourcesprint(f"evicted key:{key},{value}",end='')@lru_cache(3,evict_callback=eviction_callback)deffetch(x):print(f'miss:{x}, ',end='')returnx+1foriin[1,2,3,1,2,4,3,2,1]:print(f'get data for{i}: ',end='')fetch(i)print()Output:get data for 1: miss: 1,
get data for 2: miss: 2,
get data for 3: miss: 3,
get data for 1:
get data for 2:
get data for 4: miss: 4, evicted key: 3, 4
get data for 3: miss: 3, evicted key: 1, 2
get data for 2:
get data for 1: miss: 1, evicted key: 4, 5
Package: callbacks
Callbacks lets you use decorator syntax to set callbacks on methods or functions.[![Build Status](https://secure.travis-ci.org/14rcole/callbacks.svg?branch=master)](https://travis-ci.org/14rcole/callbacks)[![Coverage Status](https://coveralls.io/repos/github/14rcole/callbacks/badge.svg?branch=master)](https://coveralls.io/github/14rcole/callbacks?branch=master)```pythonfrom callbacks import supports_callbacksdef callback():print "Polly!"@supports_callbacksdef target():print "hello",target.add_callback(callback)target() # prints "hello Polly!"```
Package: callbook
READMEProvide some tools in C++ development.Extracted raw strings from the C++ codeThe source code ishere. The python package ishere.1. How to installpip install cjtool2. CommandA new commandstringrep.exeis added after the installation.The commandstringrepis to replace the raw string to a pointer. For exampleautom=py::module::import("test_cmake_build");// convert to the line belowautom=py::module::import(pStrTest_cmake_build);// the definiation of the string is as belowconstexprchar*pStrTest_cmake_build="test_cmake_build";Help message from the commandstringrepis as below.$ stringrep -h
usage: stringrep [-h] [-i] [-c] [-g] [-p PREFIX] file

positional arguments:
  file                  set the cpp file name

optional arguments:
  -h, --help            show this help message and exit
  -i, --inplace         replace the file in place (default: False)
  -c, --capitalize      capitalize the captured word, for example,
                        "tom" turns to "Tom" (default: False)
  -g, --generate        generate the header lines for the captured
                        strings (default: False)
  -p PREFIX, --prefix PREFIX
                        set the prefix for raw string (default: pStr)How to build and uploadpythonsetup.pybdist_wheel--universal
twineuploaddist/*Test on local machinepythonsetup.pyinstall
Package: call-center
call-centerfromcall_centerimportAgentuser="pmeier"agent=Agent(system_prompt=f"The current user is{user}")@agent.registerdefget_products(user:str):"""Get the available products for the user:param user: User to get products for."""return[f"Product{idx}"foridxin{"pmeier":[3,5,7,14]}.get(user,[])]print(agent.answer("What products are available for me?"))print(get_products(user))The available products for you are: Product3, Product5, Product7, and Product14.
['Product3', 'Product5', 'Product7', 'Product14']@agent.registerdefrank_products(products:list[str]):"""Rank products by revenue.:param products: List of products to rank."""returnsorted(products)asyncdefanswer(prompt):asyncforchunkinagent.aanswer_stream(prompt):print(chunk,end="")print()importasyncioasyncio.run(answer("What are the top three products?"))print(rank_products(get_products(user))[:3])The top three products are:
1. Product14
2. Product3
3. Product5
['Product14', 'Product3', 'Product5']
Package: callchain
Lets arbitrary callables, components, and event listeners be stringed into one lazily evaluated processing chain.Some highly contrived examples:chainstyle:>>> from callchain import aachainq as chainq
>>> chainqueue = chainq()
>>> chainqueue(('a', 1), ('b', 2), ('c', 3)).reup().wrap(dict).map().value()
{'a': 1, 'b': 2, 'c': 3}Object-oriented style:>>> chainqueue(('a', 1), ('b', 2), ('c', 3))
>>> chainqueue.reup()
>>> chainqueue.wrap(dict)
>>> chainqueue.map()
>>> chainqueue.value()
{'a': 1, 'b': 2, 'c': 3}Mirrored athttps://github.com/lcrees/callchain/
Package: callchain-checker
cccis the callchain checker used inDEAD.To build just the clang toolPrerequisites:cmake,make,clang/llvm13/14.mkdir build
cd build
cmake .. 
cmake --build . [--parallel]
cmake --install . --prefix=/where/to/install/Usagecat test.c
int bar();
int foo(){
    return bar();
}

./build/bin/ccc test.c --from=foo --to=bar --
call chain exists between foo -> barPython wrapperpip install callchain-checkerTo use the checker in python importfrom callchain_checker.callchain_checker import callchain_exists:callchain_exists(program: diopter.SourceProgram, source_function: str, target_function:str) -> boolBuilding the python wrapperLocal build./build_python_wheel_local.sh #this will build the current branch
pip install .Docker based builddocker run --rm -e REVISION=REV -v `pwd`:/io theodort/manylinux-with-llvm:latest /io/build_python_wheel_docker.shThis will build multiple wheels forREVwith multiple python versions.
The output is stored in thewheelhousedirectory.
The docker image is based onhttps://github.com/thetheodor/manylinux-with-llvm.
Package: calldecorators
By using theinspectcalllibrary,calldecoratorsdecorators
can make use of call arguments to functions at runtime, and
preserves function signature metadata (which is clobbered by most
decorators) so that this functionality works even when decorators
are stacked.Theerror_contextdecorator uses functionality fromtdxutil.exceptions.try_with_lazy_contextto wrap a function call
in an error handler that can prepend contextual information to an
error without affecting the stacktrace. This allows errors raised
b low-level code, which may not have enough information to construct
error messages indicating what was going on, to be made far more
informative.Thedebugdecorator wraps functions in a debugger post-mortem.
The debugger it uses is optionally configurable, you can
optionally set a delay so that users can bypass via keyboard
interrupt, and you can optionally toggle the behavior on and
off (for example, using global configuration).