Saravanan666/pypi-org huggingface dataset:
Package: call-detector
call_detectorcall_detectorlistens to microphone and camera states to detect if the user is participating in an online call.
Gathered information is being published to an MQTT broker.Where it worksCurrently only Linux is supported, I don't have plans to support other operating systems.
If you're interested, feel free to open a PR.In order to usecall_detectoryou'll needpulseaudioorpipewire-pulseandlibpulse.How it workscall_detectorlistens to pulseadio events to detect apps which use the microphone and uses inotify with
some /proc magic to find apps which use the camera.MQTTcall_detectorwas only tested againstmosquittoMQTT broker with login/password authentication and TLS
enabled, however in therory it can work without TLS and authentication and against any broker supported bygmqtt.Every time thecall_detectordetects an app which starts or stops using the microphone or the camera,
it publishes a message to an MQTT topic with name of the formatcall_detector/<hostname>where hostname is the hostname
of the machine where you runcall_detector. Also it sends a message on start and every minute.Message examples:{"camera": [], "microphone": [], "call": false}when camera and microphone are not active.{"camera": ["firefox"], "microphone": ["firefox"], "call": true}when user is in an online call using firefox.Installationpip install call_detectorUsageBasic usage:call_detector -H mqtt.example.com -U user -P passwordMore advanced options can be found inhelpcall_detector --helpHome AssistantBinary sensor:binary_sensor:-platform:mqttname:"Userinanonlinemeeting"state_topic:"call_detector/<hostname>"# check call_detector --help to find the default topic for your computervalue_template:"{{'ON'ifvalue_json.callelse'OFF'}}"json_attributes_topic:"call_detector/<hostname>"# same as state_topicjson_attributes_template:"{{value_json|tojson}}"qos:1Automation example:-alias:Pause music while User is in an online metingtrigger:-platform:stateentity_id:binary_sensor.user_in_an_online_meetingto:"on"condition:-condition:stateentity_id:media_player.mpdstate:"playing"action:-service:media_player.media_pausedata:entity_id:media_player.mpd-wait_for_trigger:-platform:stateentity_id:binary_sensor.user_in_an_online_meetingto:"off"-service:media_player.media_playdata:entity_id:media_player.mpdContributionYou know;)
Package: calldules
No more from <module> import <Module>!Wouldn’t be nice if…>>> import pprint
>>> pprint("hello")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callableWas possible? Well:Add special sauce:>>> import calldulesImport module(s), call:>>> import pprint
>>> pprint("hello")????'hello'PROFIT!!!Also works with such modules asflask,codecs,array,datetime,decimal,random, and many more!No responsibility is taken for any grievous harm caused either
by irresponsibleorresponsible use ofcalldules.Inspired by Richard Jones’ talkDon’t Do This.
Package: calleee
Argument matchers forunittest.mockMore robust testsPython’smocking library(or itsbackportfor Python <3.3) is simple, reliable, and easy to use.
But it is also a little lacking when it comes to asserting what calls a mock has received.You can be either very specific:my_mock.assert_called_once_with(42, some_foo_object, 'certain string')or extremely general:my_mock.assert_called_with(ANY, ANY, ANY)
# passes as long as argument count is the sameThe former can make your tests over-specified, and thus fragile.The latter could make them too broad, missing some erroneous cases and possibly letting your code fail in production.calleeeprovidesargument matchersthat allow you to be exactly as precise as you want:my_mock.assert_called_with(GreaterThan(0), InstanceOf(Foo), String())without tedious, handcrafted, and poorly readable code that checkscall_argsorcall_args_list:self.assertGreater(mock.call_args[0][0], 0)
self.assertIsInstance(mock.call_args[0][1], Foo)
self.assertIsInstance(mock.call_args[0][2], str)It has plenty of matcher types to fit all common and uncommon needs, and you can easily write your own if necessary.InstallationInstallingcalleeeis easy with pip:$ pip install calleeecalleeesupports Python 2.7, 3.6+.API referenceSee thedocumentationfor complete reference on the library usage and all available matchers.ContributingContributions are welcome!
If you need ideas, head to the issue tracker or search for the variousTODOs scattered around the codebase.
Or just think what matchers you’d like to add :)After cloning the repository, this should get you up and running:# ... create virtualenv as necessary ...
pip install -r requirements-dev.txt
toxTo regenerate documentation and display it in the browser, simply run:inv docsHappy hacking!
Package: caller
callerCaller is a little library for calling a property as a regular function.InstallationInstall using pip:$ pip install callerUsagefromcallerimportpropertyclassFoo(object):def__init__(self,bar):self._bar=bar@propertydefbar(self):returnself._bar@bar.setterdefbar(self,new_bar):self._bar=new_barfoo=Foo('bar')foo.bar('new bar')print(foo.bar)Printsnew barOr with a separate callerclassFoo(object):...@bar.callerdefbar(self,new_bar):self._bar=new_bar[::-1]print(self._bar)Foo('bar').bar('new bar')Printsrab wenThat's all.
Package: call-function-with-timeout
call_function_with_timeoutA library to make your funtions support timeoutsExampleimporttimefromcall_function_with_timeoutimportSetTimeout# make your functiondefdo_something(a=0,b=0):time.sleep(10)print(a+b)# define function with timeoutfunc_with_timeout=SetTimeout(do_something,timeout=5)# call the functionis_done,is_timeout,erro_message,results=func_with_timeout(a=12,b=8)You will find that after the method is called to the time you specified, it will return and kill the currently executing thread.You can also use it as a decoratorimporttimefromcall_function_with_timeoutimportSetTimeoutDecorator# make your function with timeout@SetTimeoutDecorator(timeout=5)defdo_something(a=0,b=0):time.sleep(10)print(a+b)# call the functionis_done,is_timeout,erro_message,results=do_something(a=12,b=8)
Package: callgg
GGUF model callerThis package is a GGUF (GPT-Generated Unified Format) file/model caller.install the caller via pip/pip3 (once only):pip install callggupdate the caller (if not in the latest version) by:pip install callgg --upgradeuser manualThis is a cmd-based (command line) package, you can find the user manual by adding the flag -h or --help.callgg -hcall gguf-selector for running a GGUF model/file:callgg runGGUF file(s) in the same directory will automatically be detected by the caller, hence, a selection menu will be shown in the console as below.save featurecallgg save [url]You might need the ssl certificate to make this feature works; install it by:pip install certifiif you don't have;
or you can upgrade your llama-core by:pip install llama-core --upgradethen it will come with those packages (certificate, new loading bar module, etc.)sample model(s) available to download (try out)For general purpose
[chat.gguf] (file size: around 2GB or less)callgg save https://huggingface.co/calcuis/chat/resolve/main/chat.ggufFor coding assistance
[code.gguf] (file size: around 3GB or more)callgg save https://huggingface.co/calcuis/code_mini/resolve/main/code.ggufFor health/medical advice
[medi.gguf] (file size: around 3GB or more)callgg save https://huggingface.co/calcuis/medi_mini/resolve/main/medi.ggufFor law/legal opinion
[law.gguf] (size: around 3GB or more)callgg save chttps://huggingface.co/calcuis/law_mini/resolve/main/law.ggufFor wealth/financial plan
[finance.gguf] (size: around 3GB or more)callgg save https://huggingface.co/calcuis/gguf/resolve/main/finance.gguf***those are all experimental models; no guarantee on quality
Package: callgraph
Callgraph is a Python package that defines a decorator, and Jupyter magic,
to drawdynamic call graphsof Python function calls.It’s intended for classroom use, but may also be useful for self-guided
exploration.The package defines a JupyterIPythonmagic,%callgraph, that
displays a call graph within a Jupyter cell:fromfunctoolsimportlru_cache@lru_cache()deflev(a,b):if""in(a,b):returnlen(a)+len(b)candidates=[]ifa[0]==b[0]:candidates.append(lev(a[1:],b[1:]))else:candidates.append(lev(a[1:],b[1:])+1)candidates.append(lev(a,b[1:])+1)candidates.append(lev(a[1:],b)+1)returnmin(candidates)%callgraph-w10lev("big","dog");lev("dig","dog")It also provides a Python decorator,callgraph.decorator, that
instruments a function to collect call graph information and render the
result.Jupyter / IPython Usage$pipinstallcallgraphIn a Jupyter IPython notebook:%load_extcallgraphdefnchoosek(n,k):ifk==0:return1ifn==k:return1returnnchoosek(n-1,k-1)+nchoosek(n-1,k)%callgraphnchoosek(4,2)As an alternative to including%load_ext callgraphin each notebook that
uses%callgraph, you can add the extension to the Notebook
configuration file in your IPython profile.Your configuration file is probably called~/.ipython/profile_default/ipython_config.py.
(You can runipython profile locateto find it.)
Edit this file to include the following line:c.InteractiveShellApp.extensions = ["callgraph.extension"](If your configuration file already includes an uncommented statementc.InteractiveShellApp.extensions = […], edit the list of extensions in
that line to include"callgraph.extension".Seeextension example notebookfor additional examples.Decorator Usage$pipinstallcallgraphfromfunctoolsimportlru_cacheimportcallgraph.decoratorascallgraph@callgraph()@lru_cache()defnchoosek(n,k):ifk==0:return1ifn==k:return1returnnchoosek(n-1,k-1)+nchoosek(n-1,k)nchoosek(5,2)nchoosek.__callgraph__.view()See theAPI documentationfor additional documentation.See thedecorator example notebookfor additional instructions and examples.DevelopmentInstall dev tools, and set up a Jupyter kernel for the current python
enviromnent:$pipinstall-rrequirements-dev.txt$python-mipykernelinstall--userInstall locally:flitinstall--symlinkAcknowledgementsCallgraph uses the Pythongraphviz package. Python graphviz uses
theGraphvizpackage.LicenseMIT
Package: call-graph
call-graphis a package for viewing call graph.$ call-graph
usage: call-graph [-h] [-p PATH] [-u] [-o] [-n NO_TARGET] module func
call-graph: error: the following arguments are required: module, func

$ call-graph call_graph main
main
├ get_names
├ get_call_graph
└ call_graph_view“NO_TARGET” is used for ignoring names.Methods are ignored.Use_ = functionfor dummy call.RequirementsPython 3.8 later, more-itertoolsFeaturesnothingSetup$ pip install call-graphHistory0.0.1 (2020-4-21)first release
Package: callgraph4py
CallGraph4PyNOTEThis is a maintained fork of the excellentPyCallGraphproject.
The latest version is1.0.1, and was released on 2013-09-17.
The next release starts from2.0.0due to deprecating Python 2.Quick StartInstallation is easy as:pip install callgraph4pyPython Call GraphWelcome! Python Call Graph is aPythonmodule
that createscall graphvisualizations for Python applications.ScreenshotsClick on the images below to see a larger version and the source code
that generated them.FeaturesSupport for Python 3.7+.Static visualizations of the call graph using Graphviz.Execute pycallgraph from the command line or import it in your code.Customisable colors. You can programatically set the colors based on
number of calls, time taken, memory usage, etc.Modules can be visually grouped together.Easily extendable to create your own output formats.
Package: callgraphdecorator
Python Call Graph Decorator#################Welcome! Python Call Graph Decorator is a `Python <http://www.python.org>`_ module with decorator for easy and effective use pyCallGraph that creates `call graph <http://en.wikipedia.org/wiki/Call_graph>`_ visualizations for Python applications... image:: https://img.shields.io/pypi/v/callgraphdecorator.svg:target: https://pypi.python.org/pypi/callgraphdecoratorQuick Start===========Installation is easy as::pip install pycallgraphdecoratorOr manually::python setup.py installDecorator is possible turn on permanently or switching ON/OFF via set system environment before start tracking application.Decorator is write very effective! Condition if graph's are creating is evaluated only ones and if condition is off ten decorator only call method.Decorator is possible set globally via system environment or locally via decorator parameters.Output::Each call decorated function create new graph in specific folder. Graphs are named as `function-name_graph-count.graph-type`Possible system environment::CREATE_CALL_GRAPH - set create graph On/Off - value True/False, true/false, 0/1 (can by set unique environment name for each decorator - state_setup_env params)CALL_GRAPH_OUTPUT_PATH - set output pathCALL_GRAPH_OUTPUT_TYPE - set output type - for example "png" (NOT ".png"!!!)Possible decorator parameters::always_on=False - graph is crating always (environment CREATE_CALL_GRAPH isn't acceptable) - default Falseoutput_folder - output folder - default "./call_graph/"output_type - output graph type - default "png"state_setup_env - enable set specific system environment for turning on/off creating graphs - default "CREATE_CALL_GRAPH"Simple use of the decorator::from callgraphdecorator import CallGraphDecorator@CallGraphDecorator(True)def test1():print("Hello Word.")if __name__ == '__main__':test1() // output - ./call_graph/test1_0.pngtest1() // output - ./call_graph/test1_1.png
Package: calligator
CalligatorAn easy-to-use library for calibrating cameras in pythonThe calibration library should follow these requirements:be able to detect points from checkerboard or charuco board easilysave intermediate points somewhere, so that optimization can restart quicklyoptimize extrinsics and intrinsics jointly using LM methodstart with opencv intrinsics calibration if possiblesupport calibration with arbitrary correspondence points using bundle adjustmentoutput common diagnostics for calibrationreprojection errorlength of checkerboard gridspicture of calibrated camera positionsundistorted images to check intrinsicstriangulation functionsend to end function to calibrate full set of cameras from list of videosNice to havesreject outlier pointsadd objective in optimization to match the object points of calibration boardFunctions to implementCameradistort_pointsundistort_pointsprojectundistort_imagecalibrate_imagescalibrate_pointscalibrate_videosCameraGroupdistort_pointsundistort_pointsprojecttriangulatereprojection_errorcalibrate_imagescalibrate_pointscalibrate_videosCalibrationObjectdrawdetect_imagedetect_imagesdetect_videoget_object_pointsestimate_pose
Package: calligraphic-rulings
Used to create calligraphic rulings for western calligraphy::Usage: ruling.py [options] output_fileOptions:-h, --help            show this help message and exit-w NIB_WIDTH, --nib-width=NIB_WIDTHWidth of the nib specified in millimeters. All othermeasurements are multiples of this.-p PARTITIONS, --partitions=PARTITIONSComma separated list of partitions in each line(specified in nib widths)-g GAP, --gap=GAP     gap between lines (specified in nib widths)--top-margin=TOP_MARGINTop margin (specified in nib widths). Default is 2-n RULINGS, --rulings=RULINGSHow many rulings to draw. Default is 10-a ANGLES, --angle=ANGLESComma separated list of angles (in degrees) for whichto draw lines on the page (for pen angle, serifs etc.)-t TITLE, --title=TITLEA title for this ruling (usually the font name)-r, --radial          Draw circles instead of straight linesSome more specifics at [http://nibrahim.net.in/2010/12/30/calligraphic_rulings.html](http://nibrahim.net.in/2010/12/30/calligraphic_rulings.html).
Package: calligraphy
Calligraphy CMSA static blog generatorInstall$pip3installcalligraphy-UDevelopment$python3-mvenv.
$.bin/activate
$pip3install--editable.
$calligraphyMethodsVerifyValidate all themes and blog posts.$calligraphyverifyExport to htmlBuilds the landing and each blog post into a statichtmldirectoryExport to html (default)$calligraphyexportStaticRun a static version of website$calligraphystatic
$calligraphystatic--port=8088TodoMarkdown parserTheme documentation404 templateTags
Package: calligraphy-scripting
CalligraphyShell scripting for the modern ageCalligraphy is a hybrid scripting language that allows you to mix Python and Bash code
in the same file. This gives you the advantages of bash when working with other
processes while also giving you the advantages of a modern language like Python.It's a free software distributed under the MIT Licence unless
otherwise specified.Development is hosted on GitHub:https://github.com/jfcarter2358/calligraphy/Pull requests are amazing and most welcome.InstallCalligraphy can be simply installed by runningpip install calligraphy-scriptingIf you want to install from a source distribution, extract the tarball and run
the following command (this requires poetry to be installed)poetry install --no-devDocumentationThe documentation lives athttps://calligraphy.readthedocs.io/.TestingWe usepytestandpytest-covfor running the test suite. You should be able to install them withpip install pytest pytest-covor you can install calligraphy alongside those packages withpoetry installTo run the test suite, you can domake testThis will produce an html coverage report under thehtmlcovdirectory.RoadmapYou can find the Calligraphy roadmaphereLicenseCalligraphy is under theMIT license.ContactIf you have any questions or concerns please reach out to me (John Carter) atjfcarter2358@gmail.com
Package: callingCardsTools
callingCardsToolsIntroductionCallingCardsToolsProvides both an API and a number of cmd line tools
for processing raw Calling Cards data. This is used in thenf-core/callingcardspipeline,
which provides a workflow to process both yeast and mammals Calling Cards data.DocumentationServed Documentationprovides
information on filetypes and the API. For help with the cmd line tools,
simply install callingcardstools (see below) and do:callingcardstools--helpEach of the cmd line tools also provides a--helpmessage.InstallationcallingCardsTools is available through bioconda:condainstall-cbiocondacallingcardstoolspypi:pipinstallcallingcardstoolsor github (this will be the most current version):pipinstallgit+https://github.com/cmatkhan/callingCardsTools.gitAfter installing, you can get help with the cmd line tools by doing:callingcardstools--helpCallingcardstools is containerized:A singularity container is hosted onGalaxyhub. If you go to this
site, make sure the 'c's have loaded and then search for 'callingcardstools'.
There is a container for each version which is on bioconda. Make sure you get
the correct version.A docker container is hosted onquay (and biocontainers).
Again, make sure you get the correct version.Development InstallationinstallpoetryI prefer to set the default location of the virtual environment to the
project directory. You can set that as a global configuration for your
poetry installation like so:poetry config virtualenvs.in-project truegit clone the repocd into the repo and issue the commandpoetry installshell into the virtual environment withpoetry shellyou canpip install -e .to install the package in editable mode. This is
useful if you want to test the cmd line interface as you make changes to the
source code.
Package: calliope-mini-stubs
CalliopeMini StubsUse this library to develop your python programs for theCalliope Miniusing a state-of-the-art python IDE such asVisual Studio Codeon your computer.This library only helps by providing documentation, type annotations and
function signatures.
It does not contain a simulator/emulator and it does not allow to transfer the
developed code to the Calliope Mini.Make sure to install this only in a local virtual environment as some
libraries overwrite "system" libraries and thus make scripts that are not
intended to run on the Calliope Mini fail.Please seethe repository on GitHubfor how a simple step-by-step instruction how to use it.
Package: calliope-music
oooooooo8             o888  o888  o88
o888     88   ooooooo    888   888  oooo   ooooooo  ooooooooo    ooooooooo8
888           ooooo888   888   888   888 888     888 888    888 888oooooo8
888o     oo 888    888   888   888   888 888     888 888    888 888
 888oooo88   88ooo88 8o o888o o888o o888o  88ooo88   888ooo88     88oooo888
                                                    o888Calliope is a toolkit for working with playlists of music.The goal is to enable research and experimentation in open source music
recommendation, by providing a set of standard interfaces and operations
to online and local music services.In order words, a way to mash up data from Spotify, Musicbrainz, Last.fm
and your local music collection!For more information, see the manual:https://calliope-music.readthedocs.io/en/latest/
Package: callipy
Dependenciesrunipy:https://github.com/paulgb/runipyIPython(tested with IPython 2.3.0)Installationpip install callipySimple UsageLet’s create a notebook callednotebook.ipynb, containing the
following cell:y = 2 * xNow let’s call this notebook from another session with a value forxand get the resulty:>>> import callipy
>>> callipy.call_notebook("notebook.ipynb", x=2).y
4How it worksFirst the keyword arguments given tocall_notebookare injected into
the notebook’s namespace andrunipyis used to execute all of its
cells:>>> result = callipy.call_notebook("notebook.ipynb", x=2)
>>> result
<callipy.NotebookResult at 0x106b92f10>After running the notebook, the value of any variable in the notebook’s
namespace can be read using attribute or dict notation:>>> result.y
4
>>> result['y']
4Note: arguments and output values must be pickleable.Finally, the notebook object itself can be accessed asresult.notebook. Seehttps://github.com/paulgb/runipyfor examples
of things you can do with the notebook object.Default values and validationThat’s all good and well, but we have a slight problem: if we try to run
the target notebook on its own, it will complain aboutxnot being
defined.The solution is to declare the parameters and their default value at the
beginning ofnotebook.ipynb:%load_ext callipy
%param x 5Now we can run the notebook from the browser, or call it without
arguments, and it will use the default value for every missing argument:>>> callipy.call_notebook("notebook.ipynb").y
10When more than one value is given, the parameter behaves as an
enumerated type and the first value is the default value:%param mode "simple", "advanced"If the notebook is called with a value that was not declared, an error
will be raised:>>> callipy.call_notebook("notebook.ipynb", mode="wrong")
ValueError: Invalid value 'wrong' for parameter mode: "simple", "advanced"You can customise this behaviour by giving as the default value an
objectmydefaultthat supports the following:mydefault[0]: returns the default valuex in mydefault: tests whetherxis allowedNote that a lone string is treated as an atomic value, not as an
enumeration of characters:%param a "test" # the default value is 'test'
%param b list("test") # the default value is 't'Finally, a notebook can be queried for the parameters it declares:>>> callipy.get_notebook_params("notebook.ipynb")
{'x': 5, 'mode': ("simple", "advanced")}Caveat: to extract this information,callipymust execute the
notebook. What if this takes time or produces side-effects? To alleviate
the problem, the instruction%params_donecan be placed in the
notebook:%param x 5
%param mode "simple", "advanced"
%params_doneThen when callingget_notebook_params()anything after this cell
will be ignored.AcknowledgmentsBased on the good work by@paulgb:https://github.com/paulgb/runipyAny reference to a famous statue is purely coincidental.