Saravanan666/pypi-org huggingface dataset:
Package: charmhelpers
OverviewCharmHelpers provides an opinionated set of tools for building Juju charms.The full documentation is available online at:https://charm-helpers.readthedocs.io/Common Usage Examplesinteraction with charm-specific Juju unit agents via hook tools;processing of events and execution of decorated functions based on event names;handling of persistent storage between independent charm invocations;rendering of configuration file templates;modification of system configuration files;installation of packages;retrieval of machine-specific details;implementation of application-specific code reused in similar charms.Why Python?Python is an extremely popular, easy to learn, and powerful language which is also common in automation tools;An interpreted language helps with charm portability across different CPU architectures;Doesn’t require debugging symbols (just use pdb in-place);An author or a user is able to make debugging changes without recompiling a charm.Dev/TestSee the HACKING.md file for information about testing and development.LicenseLicensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an “AS IS” BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Package: charming
Charming: Character Terminal Art ProgramingCharming is a creative coding language designed forCharacter Terminal Art Programming.It is currently written in Python and provides Processing-like APIs, which aims to help artists, designers, educators, beginners, and anyone else to easily create following visual effects in terminal.ASCII Art AnimationCharacter-Style Generative ArtTerminal Game ApplicationExpressive Data VisualizationThere are many reasons for creating Charming, but the most important one is thatI hope not only does Charming make you love programming for fun or show a magic world to you, but also make this journey relaxing and interesting.📎 LinksIntroductionTutorialsAPI ReferenceExamplesProcessing&P5.js to Charming✨ FeaturesHighly Expressive: Unlike traditional drawing system or tool using three numerical channels ((r, g, b)or(h, s, v)) to describe a color, Charming allows you to describe a color like(character, foreground color, background color), which means you can express more with the extra thecharacterchannel.Powerful and Flexible: Charming is not as same asurwidorclickto build console line interface. Actually it more likeasciimatics,artortchartsto draw some visual effects in the terminal but with more flexibility. Instead of drawing limited and predefined shapes or effects, you can draw some basic primitives, custom shapes, curves, images, typography with transforms (translate, rotate, shear) and even events (mouse, keyboard) in Charming.Easy to Learn and Use: Charming is very beginner-friendly, because of Python's simple syntax andProcessing's concise APIs. It will be more easier if you are already familiar with them. Once you've master Charming, you can create anything interesting in you head with it and enjoy the pure joy of coding.📦 InstallationSupported OS: Charming currently only supportsMacOS, though it should also work for any other platform that provides a workingcursesimplementation. It soon will supportWindowsand run inModern Browsers.Python: 3.6/3.7/3.8$pip3installcharming--user📺 A Simple Example'''rect.py'''importcharmingascm# draw a rectcm.full_screen()cm.rect(0,0,10,10)# run the sketchcm.run()$python3rect.py🛸 Future workUsing Rust as backend to run in browser and support multiple OS, using both JavaScript and Python as frontend.Add more API to be more expressive.Build a community and online playground like OpenProcessing.💳 LicenseCharming isLGPL-2.1 License.
Package: charmonium.async-subprocess
See the documentation of the main function:async def run(
    args: Sequence[StrBytes],
    cwd: Optional[Path] = None,
    env: Optional[Union[Mapping[StrBytes, StrBytes]]] = None,
    env_override: Optional[Mapping[StrBytes, StrBytes]] = None,
    capture_output: bool = False,
    check: bool = False,
    text: Optional[bool] = None,
) -> subprocess.CompletedProcess:
    """An async clone of `subprocess.run`.

    Suppose you have Python script that orchestrates shell commands,
    but it's too slow, and you've identified commands which can run in
    parallel. You could use `threading`, but that has GIL problems, or
    `multiprocess`, which has a high startup-cost per worker. You are
    already spinning off subprocesses, which the OS will run
    concurrently, so why not use async/await programming to express
    concurrency in a single thread?

    Note this function does not permit you to communicate
    asynchronously, just to run commands asynchronously.

    This function supports a subset of the signature of
    `subprocess.run`, that I will expand based on need. If you need
    some functionality, submit an issue or PR.

    """
Package: charmonium.determ-hash
PyPIGitHubThis library provides a deterministic hash for Python objects.hashwill give
different results each process invocation, in order to thwart denial-of-service
attacks based on intentionally triggering hash collisions (see-RinPython’s CLI options). Even settingPYTHONHASHSEEDis not enough, because
the hash can still use non-deterministic data such as pointer-addresses. By
default, this package uses thexxhashalgorithm, which is the fastest
non-cryptographic hash I know of.>>> from charmonium.determ_hash import determ_hash
>>> determ_hash(b"hello world")
141361478936837800319111455324245712876
Package: charmory
OverviewCharmory is the temporary name for the JATIC armory replacement. This name is
mostly for the use of the developers as we move function and code from Armory to
Charmory. Interim releases will be provided under this scaffolding name, although
most users will stillimport armoryas there is no Python package "charmory".Installation & ConfigurationpipinstallcharmoryWill make thearmorynamespace available to your Python environment. In the open-source
version, the installation name was "armory-testbed" which provided also provided
thearmorynamespace.Condacondaenvcreate-fenvironment.yaml-ncharmory
condaactivatecharmoryUsageSee the documentationhere.AcknowledgmentThis material is based upon work supported by the Defense Advanced Research Projects
Agency (DARPA) under Contract No. HR001120C0114. Any opinions, findings and
conclusions or recommendations expressed in this material are those of the author(s)
and do not necessarily reflect the views of the Defense Advanced Research Projects
Agency (DARPA).Points of ContactPOC: Matt Wartell @matt.wartell
DPOC: Christopher Woodall @christopher.woodall
Package: charmrunner
Automated Charm TestingReusable components and utilities forjuju:http://juju.ubuntu.comcharm testing.There are several different use cases for testing from jenkins
waterfall views, to gating publishing to a repository based on test
results.In order to accomodate different running scenarios, the tools are
presented as a set of cli tools.All the tools operate against the default juju environment.RunnerProvides the main entry point into charm testing. It will generate and
run a test and record the result and environment information:$ juju-graph-runner -r repository -w working_dir -s series -t testrecord.zip <charm_name>PlannerFor a given charm change calculate a series of test plans against a repository
of all charms:$ juju-planner -r repository  -s precise -d plans_dir <charm_name>SnapshotSnapshot and restore an environment, akin to a bzr shelve. Primary
purpose it to be able to clear out services from an environment so the
environment can be reused across tests.Operates on a service granularity, destroying and removing old services
not present in before the last snapshot in a pop:$ juju-snapshot snapshot -f pristine.json
 $ juju deploy --repository=examples local:mysql
 $ juju-snapshot restore -f pristine.json

- Clean an environment for reuse, via deleting services.
- Resets provider storage of any uploaded charms.
- Removes any charm state from zookeeper.LoaderLoad a test plan’s services and relations into an environment:$ juju-load -r repository mediawiki.planWatchVerification for a service coming up correctly, waits for a given
service and all its relations to reach a completed steady state or any
reach a failure state:$ juju-watch <service_name>Exit code 1 if the wait failed, stderr with more details. Exit 0 if succesful.Test RecordsCreate an archive of all the unit logs, zookeeper data, status, and
test runner logs:$ juju-record -f testrecord.zipCreditsKapil Thangavelu <author>
Mark Mimms <contributor>Changes0.2.5use sftp to fetch remote unit logs (juju-recorder is now provider independent)update watcher to work with new status output0.2.4standalone zk dump script, use an error handling wrapper snapshot teardown.0.2.3fix for watcher max timeout cli argument0.2.2fix for snapshot restore having multiple services reference a charm.0.2.1packaging fix
Package: charms.docker
# Charms.Docker[![Build Status](https://travis-ci.org/juju-solutions/charms.docker.svg?branch=master)](https://travis-ci.org/juju-solutions/charms.docker) [![Coverage Status](https://coveralls.io/repos/github/juju-solutions/charms.docker/badge.svg?branch=master)](https://coveralls.io/github/juju-solutions/charms.docker?branch=master)This is a library intended to ease development of docker
deliverable charms, by exposing an API that is easy to
grok at an initial glance.This library was borne from a disgust of mine at seeing manysubprocess.check_calllines littered throughout charms.
While functionally similar to what this library exposes, it
should read better than many disjointed os exec calls.This library is also targeted at python 3.3+## To use charms.dockerThis is actually embedded in the [layer:docker](http://github.com/juju-solutions/layer-docker)
runtime layer. Unless you intend on hacking this, porting it elsewhere, or otherwise
distrust the layer - you wont need to manually install this.### Examples#### Launch a one-off containerfrom charms.docker import Docker
d = Docker()
pid = d.up(‘lazypower/idlerpg:latest’, dirs={“files/idlerpg”:”/files/idlerpg”}, ports=[“8000:8000”])
payload-register(‘docker’, ‘application’, pid)#### Launch a configured container, or many containersBut you wouldn’t really want to use this terribly often, as its more sensible
to encapsulate the “configured state” of the container via a docker-compose yaml.
Which is rumored to be simple to template, and then be used like so assuming the
rendered template resides in$CHARM_DIR/files/workspace/docker-compose.yml:from charms.docker import Compose
c = Compose(‘files/workspace’)
c.up()### Get supportThis project is under heavy development pending a 0.1.0 release. Until such time
no methods should be assumed to be concrete until we land on a 1.0.0 release
chain. Any charms based on this will be at the mercy of the author to stay abreast
of the charm libraries changes.Issue Tracker: [http://github.com/juju-solutions/charms.docker/issues](http://github.com/juju-solutions/charms.docker/issues)Juju Mailing List: [juju@lists.ubuntu.com](mailto:juju@lists.ubuntu.com)
Package: charms.reactive
Charms.ReactiveThis module serves as the basis for creating charms and relation
implementations using the reactive pattern. You can see its goal and vision inthe vision documentThe full documentation is available online at:https://charmsreactive.readthedocs.io/Status - DeprecatedPlease don’t usecharms.reactivefor new charms. This library is being
maintained for existingcharms.reactivecharms, to allow bug fixes to be
made and to enable them to be built withcharm-toolsusing the reactive plugin
incharmcraft.If you are going to write a new charm, then your life, and code, will be much
easier with anOperator Frameworkcharm.UsageSeeBuilding a Charm from Layersfor more information on how to use the
charms.reactive framework. Also look at thelayer-basic documentationfor more
info on how to use the basic layer.ContributingWant to contribute? Great! We’re looking forward to your Pull Request. SeeHACKING.mdfor more information about how to contribute to charmhelpers.
Package: charms.templating.jinja2
charms.templating.jinja2Helper for rendering Jinja2 templates with charmsUsagefromcharms.templating.jinja2importrenderrender('app.conf.j2','/etc/app.conf',{'my_var':'my_val',})output=render('tmpl.j2',tests={'isnumeric':lambdas:s.isnumeric(),})output=render(template='{{ config["my-opt"]|my_upper }}',filters={'my_upper':lambdas:s.upper(),})The full documentation is available athttp://pythonhosted.org/charms.templating.jinja2/
Package: charms.unit-test
charms.unit_testThis library provides helpers for unit testing reactive style charms,
layers, and interfaces.UsageThis library is intended to be used with pytest andconftest.py, which
allows for mocking out imports prior to the test code being loaded.Exampleconftest.py:fromcharms.unit_testimportpatch_reactive,patch_module# patch common things needed by any reactive charmpatch_reactive()# patch some other module that the charm expects to be therepatch_module('charms.leadership')With this, your test code can import the charm's reactive code which
depends on charms.reactive and charmhelpers without error, and the
libraries will be mocked out so that you can call your handlers
directly to test them.ReferenceMore details on what is patched, as well as what other helpers are available,
can be found inthe reference docs.
Package: charm-test
This package sports a collection of helpers for unit-testing Juju charms.In particular, it extendssystemfixturesby faking out hook tools
processes (config-get,juju-log, etc), so authors have a complete suite
of fakes for the typical “boundaries” of a Juju charm.>>>fromtesttools.matchersimportDirExists>>>>>>fromcharmtestimportCharmTest>>>>>>fromcharmhelpers.coreimporthookenv>>>>>>>>>defexample_charm_logic():...return{..."service-name":hookenv.service_name(),..."local-unit":hookenv.local_unit(),..."charm-dir":hookenv.charm_dir(),...}>>>>>>>>>classExampleCharmTest(CharmTest):......deftest_charm_logic(self):...result=example_charm_logic()...self.assertEqual("test",result["service-name"])...self.assertEqual("test/0",result["local-unit"])...self.assertThat(result["charm-dir"],DirExists())>>>>>>>>>ExampleCharmTest(methodName="test_charm_logic").run().wasSuccessful()TrueSupport and DocumentationSee theonline documentationfor
a complete reference.Developing and ContributingSee theGitHub project. Bugs
can be filed in the issues tracker.
Package: charm-tools
This is a collection of tools to make writing Juju charms easier. See Juju’s
home page for more information.https://jujucharms.com/InstallationTo run the latest stable release, use:sudo snap install charm --classicYou’ll also almost certainly want to install Juju as well:sudo snap install juju --classicIf you want to run the latest pre-release versions, you can use the
other snap channels.  For example:sudo snap install charm --channel=edgeThe available channels are: stable, candidate, beta, and edge.Note: While charm-tools is also available on PyPI (for use as a Python
dependency) and is generally kept up to date there with stable releases,
the snap should always be used instead, if at all possible.UsageTo see a list of available commands, use:charm helpThe most commonly used commands are the charm life-cycle commands:charm create    # create a new charm
charm build     # build a charm using layers
charm proof     # validate a charm via the linter
charm login     # login to the charm store
charm push      # push a charm to the store
charm release   # release a pushed charm to the public
charm show      # show information about a charm in the store
Package: charmy
An automated PyCharm installer for Linux.Supported systemsAlthoughcharmywould work on any Linux system (download, sym-link), some
extra things, like creating a.desktopfile for Ubuntu launcher, are done for
specific systems only.InstallationInstall with latest stable version from PyPI:pipinstallcharmyOr install the latest stable version from GitHub:pipinstall-egit+https://github.com/barseghyanartur/charmy@stable#egg=charmyOr install the latest stable version from BitBucket:pipinstall-ehg+https://bitbucket.org/barseghyanartur/charmy@stable#egg=charmyOr install into python path:$pythonsetup.pyinstallThat’s all. See theUsage and examplessection for more.Usage and examplesBasicsInstall the latest version of PyCharm (defaults to community edition):charmyinstallYou may be more explicit as well:charmyinstall--edition=communityInstall the latest professional version:charmyinstall--edition=professionalInstall specific version of the PyCharm. Let’s assume the you want
to install community edition version 4.5.4:charmyinstall--version=4.5.4--edition=communitySwitch between installed PyCharm versions (imagine, you have both 4.5
and 4.5.4 installed and want to switch back to previous version):charmyactivate--version=4.5--edition=communityList installed PyCharm versions:charmyversionsBy defaultcharmyinstalls PyCharm in thePyCharmdirectory. If you want it
to be installed elsewhere provide –destination directive:charmyinstall--destination=/home/user/my-pycharm-installation-directory/Note, thatcharmyremembers your last destination, so once you have
specified a destination, you don’t have to specify it again (unless you
want to change installation directory).Check for the latest available version (without installing it):charmycheck-latest-availableClearcharmysettings (destination and the database drop):charmyreset-settingsUbuntuWhen installing on Ubuntu,charmycreates a.desktopfile for to be drag
and dropped to the Unity launcher. The.desktopfile is located at:~/.local/share/applications/jetbrains-pycharm-ce.desktopLicenseGPL 2.0/LGPL 2.1SupportFor any issues contact me at the e-mail given in theAuthorsection.AuthorArtur Barseghyan <artur.barseghyan@gmail.com>
Package: charnetto
CharnettoThis module is designed to create an automated character network based on a book or a movie script.Getting startedCharnetto is implemented both with spaCy and Flair for the named entity recognition step. Please install the desired library usingpip install spacyorpip install flairFor more information, see theonline documentation.How to use charnettoYou can use the Jupyter Notebookcharnetto_example.ipynbto see a full example of how to generate a character network based on a book (with Flair as a NER tool or with manual annotations) or on a movie script.Supported dataThe books must be in.txt, ideally with one paragraph per line. For english books, replacing,'by',at the end of dialogues tends to give better results with the NER part.The movie scripts need to resemble those available onIMSDB: the regex for character names looks for capital letters preceded by at least two line breaks.If you want to annotate some books manually, you can follow the URL notation in Markdown to identify characters. Online editors likeStackEditallow you to double-click on a name and add an URL (withCTRL+L). By writingPERin the URL part (for the tag "PERSON"), you will then be able to use charnetto to extract the annotated entities and generate a character network.
Package: charonload
CharonLoadCharonLoad is a bridge between Python code and rapidly developed custom C++/CUDA extensions to make writinghigh-performance research codewithPyTorcheasy:🔥 PyTorch C++ API detection and linking🔨 Automatic just-in-time (JIT) compilation of the C++/CUDA part📦 Cached incremental builds and automatic clean builds🔗 Full power of CMake for handling C++ dependencies⌨️ Python stub file generation for syntax highlighting and auto-completion in VS Code🐛 Interactive mixed Python/C++ debugging support in VS Code viaPython C++ DebuggerextensionCharonLoad reduces the burden to start writing and experimenting with custom GPU kernels in PyTorch by getting complex boilerplate code and common pitfalls out of your way. Developing C++/CUDA code with CharonLoad feels similar to writing Python scripts and lets you follow the same familiar workflow.InstallationCharonLoad requiresPython >=3.8and can be installed from PyPI:pipinstallcharonloadQuick StartCharonLoad only requires minimal changes to existing projects. In particular, a small configuration of the C++/CUDA project is added in the Python part while the CMake and C++ part should adopt some predefined functions:<your_project>/main.pyimportcharonloadVSCODE_STUBS_DIRECTORY=pathlib.Path(__file__).parent/"typings"charonload.module_config["my_cpp_cuda_ext"]=charonload.Config(project_directory=pathlib.Path(__file__).parent/"<my_cpp_cuda_ext>",build_directory="custom/build/directory",# optionalstubs_directory=VSCODE_STUBS_DIRECTORY,# optional)importother_module<your_project>/other_module.pyimportmy_cpp_cuda_ext# JIT compiles and loads the extensiontensor_from_ext=my_cpp_cuda_ext.generate_tensor()<your_project>/<my_cpp_cuda_ext>/CMakeLists.txtfind_package(charonload)if(charonload_FOUND)charonload_add_torch_library(${TORCH_EXTENSION_NAME}MODULE)target_sources(${TORCH_EXTENSION_NAME}PRIVATEsrc/<my_bindings>.cpp)# Further properties, e.g. link against other 3rd-party libraries, etc.# ...endif()<your_project>/<my_cpp_cuda_ext>/src/<my_bindings>.cpp#include<torch/python.h>torch::Tensorgenerate_tensor();// Implemented somewhere in <my_cpp_cuda_ext>PYBIND11_MODULE(TORCH_EXTENSION_NAME,m){m.def("generate_tensor",&generate_tensor,"Optional Python docstring");}ContributingIf you would like to contribute to CharonLoad, you can find more information in theContributingguide.LicenseMITContactPatrick Stotko -stotko@cs.uni-bonn.de
Package: charprinto
Charprinto!Replace all that unnessasary "import sys" and "for i in string" with "from charprinto import charprint" and "charprint("I love charprinto!", 'red' cursorused=False, end="")"!NOTE: There is now the "blanket()" function!
NOTE: There is now the "charinput()" function!
Woo! Version 2.0.1!
Contact me ataverse.abfun@gmail.com
Package: charpy
This is a web app designed to crunch data into charts, maybe like a
dashboard.ReleaseVersion 1For this version the goals were:Create an API in python that can be customized easily (finding an
implenting a framework)Provide a flexible api that can render csv files into charts (only
basic ones will work)Have the possibility to render more than one chart per pageHave the possibility to color the charts automaticallyProvide an endpoint so that you can use http request to get the csv
data into jsonProvide an html view of the csv dataHave a start with SQL compatibilitiesHave all functionality developed using TDD (test driven development)
as much as possibleDemoYou can have a demo available atlocalhost:5001pythoncharpy/factory.pyDependenciesUsed for this project:PythonFlask - base of the microservice (Jinja2 for templating)SQLAlchemy - for SQL database manipulation (not really implemented at
the moment)Pandas - for the dataframe object and data manipulationdateutils - for the date and time parserJavascriptChart.js - for displaying the chartsOther AlternativesI want to display other alternatives because well, this is a bit missing
in feature as of now, and you might want to know what is being developed
and maintained.plotly - Dash: flask framework
using react and plotpy to display charts in a nice dashboard.anaconda - Bokehdepends on
Jinja2 for templating, bokeh server and js library for chartjwkvam - bowtie: sockets.io,
flask and react to create dashboard
Package: charred
CharredVery simple package withis_ascii_char,is_same_char,is_string,is_unicode_charandrepeat_charmethods.I will probably add more later.Install package:pip install charred

# or pip3Usage:from charred import is_ascii_char, is_same_char, is_string, is_unicode_char, repeat_char

>>> is_ascii_char('$')
True
>>> is_ascii_char('£')
False

>>> is_same_char('FF')
True
>>> is_same_char('FD')
False

>>> is_string('F')
True
>>> is_string(1)
False

>>> is_unicode_char('£')
True
>>> is_unicode_char('F')
False

>>> repeat_char('F', 6)
FFFFFF