Saravanan666/pypi-org huggingface dataset:
Package: casserole
casserolecasseroleabstracts the process of
reading configuration values from multiple sources.casserolewill also
dynamically create anOptionParserfrom your settings definitions.The goal of the project is to:> Eliminate code duplication when handling run-time configuration from varioussources, (i.e. command-line options, environment variables, JSON files) and
allow programmers to define their application’s settings using memorable APIs.
Package: cassette
Cassette stores and replays HTTP requests made in your Python app.importurllib2importcassettewithcassette.play("data/responses.yaml"):# If the request is not already stored in responses.yaml, cassette# will request the URL and store its response in the file.r=urllib2.urlopen("http://www.internic.net/domain/named.root")# This time, the request response must be in the file. The external# request is not made. cassette retrieves the response from the# file.r=urllib2.urlopen("http://www.internic.net/domain/named.root")assert"A.ROOT-SERVERS.NET"inr.read(10000)Cassette also supports therequestslibrary.importrequestswithcassette.play("data/responses.yaml"):r=requests.get("http://www.internic.net/domain/named.root")Note that requests stored between different libraries may not be compatible with
each other. That is, a request stored withurllib2might still trigger an external
request is the same URL is requested withrequests.Installation$pipinstallcassetteDocumentationLatest documentation:cassette.readthedocs.orgLicensecassette is available under the MIT License.Copyright Uber 2013, Charles-Axel Dein <charles@uber.com>
Package: cassette-django
Django middleware for cassette.devInstall withpip install cassette-djangoAddcassette_djangoto your installed apps.INSTALLED_APPS = [
    ...
    'cassette_django',
    ...
]Add the middleware as at the end of the middleware listMIDDLEWARE = [
    ...
    'cassette_django.middleware.CassetteMiddleware,
]Now you're good to go! To import your API just install cassette's cli (npm install -g @cassette.dev/cassette-clior read more atnpmjs.com)
and follow the instructions.
Package: cassini
CassiniNote Cassini is in it's alpha development stage, so things may not work perfectly - tell us about problems so we can fix them!An electronic laboratory notebook (ELN), built inside Jupyter Lab.Cassini's goal is to help you explore, analyse and organise your data in an environment that's familiar.FeaturesStructures your projectinto an easy to navigate hierarchy of workpackages, experiments, samples and datasets.Allowsretrieval of data by namee.g.project['WP3.2f-XRD'] / 'XRD_data.csv.Create new sample, experiment (etc.) notebooks throughcustom dialogs.Create notebook templates forstandardised proceedures.Browse and exploreyour project through a custom browser, including previewing cell outputs, such as plots in-browser.No magic! Everything is stored in regularhuman navigatable folders, cloud backups etc. work as expected.Check out the demo binder for a walkthrough of features (note this can take a little while to load):Installation and Setup> pip install cassiniCreate aproject.py:# project.py
from cassini import Project, DEFAULT_TIERS
from cassini import jlgui

project = Project(DEFAULT_TIERS, __file__)
jlgui.extend_project(project)

if __name__ == '__main__':
    project.launch()And launch it:> python project.pyHead toQuickstartfor more info.ContributingContributing guidelines are foundhere.This includes development installation instructions and codebase orientation.
Package: cassio
cassIOA framework-agnostic Python library to seamlessly integrate Apache Cassandra with ML/LLM/genAI workloads.Note: this is currently an alpha release.UsersInstallation is as simple as:pip install cassioFor example usages and integration with higher-level LLM frameworks
such as LangChain, please visitcassio.org.CassIO developersSetupTo developcassio, use therequirements-dev.txt.To use the dev version in an integration (e.g. your branch of LangChain),pip install -e .in thiscassiorepo from within the virtual environment
you are using to develop your integration.PoetryIf the integration is Poetry-based (e.g. LangChain itself), you should get this
in yourpyproject.toml:cassio = {path = "../../cassio", develop = true}Then you dopoetry remove cassio                                      # if necessary
poetry lock --no-update
poetry install -E all --with dev --with test_integration  # or similar, this is for langchainInspired from this.
You also need a recent Poetry for this to work.VersioningWe are still at0.*. Occasional breaking changes are to be expected,
but please think carefully. Later, a stronger versioning model will be adopted.Style and typingStyle is enforced throughblack, linting withruff,
and typechecking withmypy.
The code should run throughmake formatwithout issues.Python version coverageAt the moment we try to run tests under Python3.8 and Python3.10 to try and
catch versions-specific issues
(such as the newertypingsyntax such astypeA | typeB, illegal on 3.8).PublishingBump version in setup.pyAdd toCHANGES.txtCommit the very code that will be built:git tag v<x.y.z>; git push origin v<x.y.z>rm dist/cassio*
make build
twine upload dist/cassio*  # (login to PyPI ...)TestingPlease run tests (and add some coverage for new features). This is not
enforced other than to your conscience. Typemakefor the available tests.To run the full tests (except specific tests targeting Cassandra),
there'smake test-all.Unit testingYou need a virtualenv with therequirements-dev.txtinstalled.make test-unitIntegration with the DBYou need a virtualenv with therequirements-dev.txtinstalled.Ensure the required environment variables are set (see for instance
the providedTEMPLATE.testing.env).
You need at least one of either Astra DB or a
Cassandra (5+) cluster to use.Launch the tests with either of:make test-integration
make test-astra-integration
make test-cassandra-integrationThe latter two above specifyTEST_DB_MODEas eitherLOCAL_CASSANDRAorASTRA_DB.Ideally you should test with both, since some tests are
skipped in either case.
Package: cassowary
This project is being dusted offThis project was transferred to Brodderick Rodriguez in February 2020 who will oversee its development from here on out.A big thanks to Russell for his original authorship of this project.CassowaryA pure Python implementation of theCassowary constraint-solving algorithm.
Cassowary is the algorithm that forms the core of the OS X and iOS visual
layout mechanism.QuickstartCassowary is compatible with both Python 2 or Python 3. To install Cassowary
in your virtualenv, run:$ pip install cassowaryThen, in your Python code, you can create and solve constraint systems. Seethe documentationfor examples of what this looks like in
practice.DocumentationDocumentation for Cassowary can be found onRead The Docs.CommunityNotice: Cassowary is no longer part of the BeeWare suite.You can talk to the community through:Tweet Brodderick on Twitter:@teamskynet_ContributingIf you experience problems with Cassowary,log them on GitHub. If you
want to contribute code, pleasefork the codeandsubmit a pull request.Project AdministrationThis project was transferred to Brodderick Rodriguez in February 2020 who will continue to oversee its development from here on out.Russell Keith-Magee is the original author of this work. A big thanks to him for his work! Check outRussell’s GitHub.
Package: cassowarypy
This is a python wrapper over the (famous) Cassowary incremental constraint solver.
It uses the c++ implementation (0.6) as backend.The original c++ code is somewhat refactored to remove memory leaks
by using reference counting, and is usable alone.The refactoring was done somewhen in 2002, and the code is not touched much since then.
Last changes are workarounding recent template-things in new (gcc-4.x) c++ compilers.
The Finite-domain part (using GTL graph library) is not tried/tested; it might or might not work.repository: svn cohttps://dbcook.svn.sf.net/svnroot/dbcook/cassowarypyhow to compile/install for python:the c++ code now compiles on both g++ 3.3.3 and g++ 4.1.3.
it also compiles on some MSVC.‘swig’ is also neededif the default C++ compiler is one of those, just ‘python setup.py install’ would do.
Then run python test.py to see if all works.else, u have to install one of these compilers and fight with distutils to make it use that one.
e.g. “CC=g++-3.3 python setup.py install” might work; also check the link’ing partMy code is under MIT-license.
Original Cassowary code is licensed under LGPL.Original cassowary Web Page: (last update about year 2000)http://www.cs.washington.edu/research/constraints/cassowary
Package: casstest
Just a quick dockerfile test for my entertainmentFree software: BSD licenseDocumentation:https://casstest.readthedocs.org.FeaturesTODOHistory0.7.0 (2015-01-14)Add stresstest script0.6.0 (2015-01-14)Add requirements to setup.py0.5.0 (2015-01-14)Fix test bugs0.4.0 (2015-01-14)Fix setup bug0.3.0 (2015-01-14)Fix import bug0.2.0 (2015-01-14)Add console script and docker0.1.0 (2015-01-14)First release on PyPI.
Package: cassy
Python Cassandra Database APIInstallationPlease see theInstallation Guide(Github Repo Link) for details.UsagePlease see theWorklow Reference(Github Repo Link) for details.ContributingContributions are very welcome.
To learn more, see theContributor Guide(Github Repo Link).LicenseDistributed under the terms of theMIT license(Github Repo Link),cassyis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was created using theMathias Ammontweaked version of theHypermodern-Pythonproject foundation proposed byClaudio Jolowicz.
Package: cassyy
cassyyA simple Apereo Central Authentication Service (CAS) client that provides basic
support for validating service tickets using CAS Protocols 2/3. It uses the
Python standard libraryurllib.requestmodule and has no external
dependencies.UsageBelow provides just an example of how it might be used in a web
application. The example is generic and does not represent any specific web
framework. It is up to the application to decide whatservice_urlit will
use with thebuild_login_urlmethod. It is common to use the current request
url or a fixed url that CAS will redirect the user to after the login is
successful along with aticketthat can be validated to retrieve information
about the user.importcassyycas_client=cassyy.CASClient.from_base_url('https://cas.example.org')deflogin_route(request,response):redirect_url=...target_url=cas_client.build_login_url(redirect_url)response.redirect(target_url)# This could be a route or some authentication middleware that intercepts# unauthenticated requests and redirects to CAS and/or validates a CAS ticket# if one is included in the request.defvalidate_route(request,response):ticket=...# pull from requestservice_url=...cas_user=cas_client.validate(service_url,ticket)request.session['user']=cas_user.asdict()deflogout_route(request,response):# where to have CAS redirect back to the app after the CAS logout occurs,# or None to use the CAS logout pageservice_url=...target_url=cas_client.build_logout_url(service_url)response.redirect(target_url)
Package: cast-ai-se-cli
CAST AI SE CLI (cast-ai-se-cli package | se-cli tool)Introduction / OverviewThis project aims to serve as swiss knife intended to serve CAST AI SEs.
Assisting with demo environment prep, providing snapshot analysis and many others in the future.
The CLI tool is based on a modular architecture and leverages API orchestration tools package -> cast-ai-se-toolsTable of ContentsInstallationUsageContributingLicenseInstallationTo install, run:pip install cast-ai-se-clior forced:pip install cast-ai-se-cli --force-reinstallTo upgrade, run:pip install --upgrade cast-ai-se-clior forced:pip install --upgrade --force-reinstall cast-ai-se-cliUsageFor some of the functions(commands) the tool offers a configuration file is required (config.json).First time running the tool if file is not found, the tool would create an empty template file.The user is required to fill fields required to automate sequences related to the chosen command.The template comes with additional default parameters that can foundhereHigh-Level:CLI commands:se-cli demo <prep|off> <eks|aks|gcp> [--cluster_id <cluster_id>] [-h|--help] [-d|--debug]
se-cli snapshot <analyze> <brief|detailed> [--cluster_id <cluster_id>] [-h|--help] [-d|--debug]
se-cli audit <analyze> [--cluster_id <cluster_id>] [-h|--help] [-d|--debug]CLI commmands explained:se-cli demo <prep|off> <eks|aks|gcp>demo command is used to eitherprepa demo environment:Use the config.json data to get the cluster into a specific node count (default=7)with specific replicated demo replicas (default=2) and then delete previous nodes
Turningoffa cluster would be invoking the hibernation cronjob.The subcommand<eks|aks|gcp>is to determine which cluster will be prep`ed or turned off.\se-cli snapshot  <brief|detailed>snapshot command is used to either generate abriefordetailedreport of workloads that have some effect on
scheduling:nodeSelectortopologySpreadConstraintsaffinityruntimeClassNamepdb`sWorkloads analyzed:deploymentsreplicaSetsdaemonSetsstatefulSetsjobsThe detailed report includes the namespaces and names of workloadsOptions:-h, --help  Show this help message and exit.
-d, --debug  Enable debug logging.
-c, --cluster_id <cluster_id>  (Optional) Specify the cluster ID for the demo environment.Command->Outcome:se-cli demo prep:se-cli demo off:Hitting a timeout:se-cli audit analyze:ContributingContributions are welcome! To contribute, follow these steps:git clone project as first step
create features/fixes by applying a simple <TYPE(fix/feature...)>/<INITIATING_USER>-<FEATURE/FIX-NAME> branch
do not forget to update version and open a PR
Please make sure CI process that enforces light flake8 lint passes (flak8 and other helper script can be found in helper_script folder)LicenseThis project is licensed under theAPACHE License.RoadmapVersion 0.1.0: First semi-major release end of 2023 Q4 - tested and vetted demo functionalityVersion 0.2.0: Second semi-major release to support snapshots analysisVersion 0.3.0: Third semi-major to integrate with solution-engineering toolVersion 1.0.0: First Major release tested and vetter all other previous releases (end of 2024 Q1)
Package: cast-ai-se-tools
cast-ai-se-tools packageOverviewCast AI SE Package: is a python package intended to serve tools required by Cast AI`s customer success team.
Purpose: not to have to invent the wheel creating functions that can created once and leveraged via a package.InstallationYou can installcast-ai-se-toolsusing pip:pipinstallcast-ai-se-toolsCaveatsTo leverage Azure automations make sure you:
Create an App and provide it Read/Write permissions to:*AKS*Log Analytics*Resource Group
Package: castaway
A simple wrapper forpython-dotenvthat allows for easy casting of environment
strings to various data types.InstallationStandard install:pip install castawayIf you want Django integration (dj-email-url,dj-database-url), do:pip install castaway[django]ExampleEasiest form is:fromcastawayimportconfigSOME_SETTING=config('SOME_SETTING',default=None)Likepython-dotenv, this will load.envfrom the current working directory,
or walk the parent directory tree until it is found.For more custom usage, you can specify the exact name and path to whatever file you need.
For instance, using thetests/.envfile from this repo.fromdatetimeimportdatetimefromcastawayimportConfigconfig=Config('tests/.env')CASTAWAY_INT=config('CASTAWAY_INT',cast=int)assertCASTAWAY_INT==23CASTAWAY_LIST=config('CASTAWAY_LIST',cast=list)assertCASTAWAY_LIST==['a','b','c']CASTAWAY_DATETIME=config('CASTAWAY_DATETIME',cast=datetime.fromisoformat)assertCASTAWAY_DATETIME==datetime(2021,4,3,14,25)
Package: castbot
CastBotA Telegram Bot to stream contents (Telegram videos, Youtube videos and more) to your smart TVDemonstration videoFeatureStream Telegram videos to any device that supports UPnP (AVTransport), Chromecast, Vlc (telnet api), Kodi (xbmc http api)Web interface that plays videos in your browserDownload videos by URLs and stream to devicesKnown issuesChromecast (1st, 2nd and 3rd Gen.)only supports H.264 and VP8 video codecsMost LG TVs with WebOS have an incorrect UPnP implementationThis bot supports videos of ~4.5Mb/s bit rate at maximum. The videos of higher bit rate would keep freezing.How to run castbot with pipCreate a configuration fileconfig.tomland then run the following commandpipinstallcastbot
castbot-cconfig.toml-v1Note: Make sure you have a version of Python 3.8+How to run castbot with DockerCreate a configuration fileconfig.tomland then run the following commanddockerrun--networkhost-v"$(pwd)/config.toml:/app/config.toml:ro"-dghcr.io/zhongkechen/castbot:masterHow to configCreate a fileconfig.tomlwith the following content[downloader]# Use yt-dlp or you-get to download Youtube videosdownloader="yt-dlp"# how many concurrent downloadsconcurrency=10[bot]# `api_id` and `api_hash` can be generated here: https://core.telegram.org/api/obtaining_api_idapi_id=652324api_hash="eb06d4abfb49dc3eeb1aeb9f581e"# `token` can be created from https://telegram.me/BotFathertoken="xxxxxxxxx"# `session_name` can be an arbitary string.session_name="castbot"# Only users in this `admins` list can use this bot.# Your own user id can be found here https://telegram.me/getuseridbotadmins=[337885031,32432424,44353421][http]# The IP address or the hostname of the host running castbotlisten_host="192.168.1.2"# An arbitary port that is not in uselisten_port=8350# The following devices sections are optional. Add the sections you need.[[devices]]# When this section is added, all the UPNP devices in the local network will be auto-discovered.# For Kodi, UPNP must be enabled in Settings -> Services -> UPNP/DLNA# https://kodi.wiki/view/Settings/Services/UPnP_DLNAtype="upnp"[[devices]]# When this section is added, all the ChromeCast devices in the local network will be auto-discovered.type="chromecast"[[devices]]# When this section is added, open http://`listen_host`:`listen_port`/static/index.html in a browser.# Now if you send a video to the bot, you can choose to play it in the browsertype="web"password="changeit"[[devices]]# When this section is added, we can play video on a device running VLC.# VLC Telnet interface must be enabled.type="vlc"host="127.0.0.1"port=4212password="123"[[devices]]# When UPNP is blocked by firewall, we can use this section to connect to Kodi.# Remote Control of Kodi must be enabled: Settings -> Services -> Control.# https://kodi.wiki/view/Settings/Services/Controltype="xbmc"host="192.168.42.140"port=8080username=""password=""
Package: castctrl
A Python program to simplify casting video to a ChromecastUsageusage: castctrl [-h] [--url URL] [--power] [-s] [-d DEVICE] [-D] [--port PORT]

optional arguments:
  -h, --help            show this help message and exit
  --url URL             URL of media to play. You should probably specify this
                        if nothing else
  --power               Turn on TV and switch to Chromecast
  -s, --stop            Stop playback
  -d DEVICE, --device DEVICE
                        Select device. List devices with -D
  -D, --devices         List devices
  --port PORT           Specify port for web server (if you pick a local file
                        above)InstallationViapip:pip3 install castctrlAlternatively:Clone the repository,cd castctrlRunpython3 setup.py installorpip3 install-e
Package: castellan
Generic Key Manager interface for OpenStack.License: Apache License, Version 2.0Documentation:https://docs.openstack.org/castellan/latestSource:https://opendev.org/openstack/castellanBugs:https://bugs.launchpad.net/castellanRelease notes:https://docs.openstack.org/releasenotes/castellanWiki:https://wiki.openstack.org/wiki/CastellanTeam and repository tags
Package: castellan-ui
Generic Key Manager UI Plugin for HorizonFree software: Apache licenseSource:http://git.openstack.org/cgit/openstack/castellan-uiBugs:http://bugs.launchpad.net/castellan-uiFeaturesTODOEnabling in DevStackAdd this repo as an external repository into yourlocal.conffile:[[local|localrc]]
enable_plugin castellan-ui https://github.com/openstack/castellan-uiManual InstallationBegin by cloning the Horizon and Castellan UI repositories:git clone https://github.com/openstack/horizon
git clone https://github.com/openstack/castellan-uiCreate a virtual environment and install Horizon dependencies:cd horizon
python tools/install_venv.pySet up yourlocal_settings.pyfile:cp openstack_dashboard/local/local_settings.py.example openstack_dashboard/local/local_settings.pyOpen up the copiedlocal_settings.pyfile in your preferred text
editor. You will want to customize several settings:OPENSTACK_HOSTshould be configured with the hostname of your
OpenStack server. Verify that theOPENSTACK_KEYSTONE_URLandOPENSTACK_KEYSTONE_DEFAULT_ROLEsettings are correct for your
environment. (They should be correct unless you modified your
OpenStack server to change them.)Install Castellan UI with all dependencies in your virtual environment:tools/with_venv.sh pip install -e ../castellan-ui/And enable it in Horizon:ln -s ../castellan-ui/castellan_ui/enabled/_90_project_key_manager_panelgroup.py openstack_dashboard/local/enabled
ln -s ../castellan-ui/castellan_ui/enabled/_91_project_key_manager_x509_certificates_panel.py openstack_dashboard/local/enabled
ln -s ../castellan-ui/castellan_ui/enabled/_92_project_key_manager_private_key_panel.py openstack_dashboard/local/enabled
ln -s ../castellan-ui/castellan_ui/enabled/_93_project_key_manager_public_key_panel.py openstack_dashboard/local/enabled
ln -s ../castellan-ui/castellan_ui/enabled/_94_project_key_manager_symmetric_key_panel.py openstack_dashboard/local/enabled
ln -s ../castellan-ui/castellan_ui/enabled/_95_project_key_manager_opaque_data_panel.py openstack_dashboard/local/enabled
ln -s ../castellan-ui/castellan_ui/enabled/_96_project_key_manager_passphrase_panel.py openstack_dashboard/local/enabledTo run horizon with the newly enabled Castellan UI plugin run:./run_tests.sh --runserver 0.0.0.0:8080to have the application start on port 8080 and the horizon dashboard will be
available in your browser athttp://localhost:8080/
Package: castellum-pseudonyms
Castellum PseudonymsAlgorithms to generate, validate, and normalize pseudonyms.This is part of thecastellum
project.Installationpip install castellum-pseudonymsUsagefrom castellum_pseudonyms import generate, clean

# generate a new random pseudonym
pseudonym = generate(bits=40)

# normalize and validate a pseudonym entered by a user
try:
    pseudonym = clean(user_input)
except ValueError:
    print('invalid pseudonym')