Saravanan666/pypi-org huggingface dataset:
Package: colour-text
colour_textcolour_text and colour-print commandcolour-printis a command that makes printing coloured text
easier to do on Unix, macOS and Windows. It uses theColourTextclass to colour the text.The command uses markup using<>colour-name text<>.$colour-print"<>info Info:<> this is an <>em informational<> message"$colour-print"<>error Error: This is an error message<>"The first argument is treated as a format string if there are more arguments.$colour-print"<>info Info:<> Home folder is %s""$HOME"class ColourTextTheColourTextclass converts strings with colour markup into
a form suitable for printing on a terminal that support colour
text. This include most terminal emulators on macOS, Windows
and Unix.To colour a section of text use the marker followed by the colour
name a space and the text to be coloured ending with the marker.fromcolour_textimportColourTextct=ColourText()ct.initTerminal()print(ct.convert("The next section is in green: <>green example<>."))To include the marker as literal text use two adjacent markers.fromcolour_textimportColourTextct=ColourText()ct.initTerminal()print(ct("A <>red literal marker<> <><> in the string"))ColoutText can be use with gettext for internationalized applications.fromcolour_textimportColourTextct=ColourText()ct.initTerminal()message="<>red Error: cannot open file%s<>"i18n_message=_(message)coloured_i18n_message=ct(i18n_message)formatted_message=coloured_i18n_message%(file_name,)print(formatted_message)# or in one lineprintct(_("<>red Error: cannot open file%s<>"))%(file_name,))class ColourText__init__( marker='<>' )Themarkeris the string used to markup the colour sections
which defaults to<>.initTerminal()Ensure the terminal can display coloured text.Must be called on Windows and can be safely called on macOS and Unix systems.define( name, colour_def )Define a colournamefor use in the marked up sections.
Thecolour_defis a list of existing colour names
or a single name.The builtin foreground colour names are:bold, black, brown, green, yellow, blue,
  magenta, cyan, gray, red, lightred, lightgreen,
  lightyellow, lightblue, lightmagenta, lightcyan
  and white.The builtin background colour names are:bg-black, bg-brown, bg-green, bg-yellow,
  bg-blue, bg-magenta, bg-cyan, bg-gray
  and bg-white.For example add the nameinfoas green text anderroras
to be red text on a white background:ct=ColourText()ct.define('info','green')ct.define('error',('red','bg-white'))ct("Error messages are <>error shown like this<>")convert( colour_text )Interpret the colour markup in the colour_text string
and return a string suitable for printing on the terminal.__call__( colour_text )Callconvert( colour_text )in a concise way.
Package: colourtime
pipinstallcolourtimeColourtime converts an Event Stream file (.es) into a PNG image, where time is represented with colour gradients.The pip package installs a Python library (import colourtime) and command-line executable (colourtime).The following command converts an Event Stream file.colourtime/path/to/input.esRuncolourtime --helpto list available options.Checkpython/init.pyfor details on the Python API.Build from sourcepython3-mvenv.source./bin/activate
pip3install-Upipevent_streammatplotlibmaturinnumpypillow
maturindevelop-rFormatisort .; black .; pyright .
Package: colour-valgrind
A python wrapper for Valgrind that colours the output for better readability.Available on pypi here https://pypi.python.org/pypi/colour-valgrind/Installation------------```pip install colour-valgrind```or from the root dir (after cloning):```pip install -e .```Usage-----Just use `colour-valgrind` instead of `valgrind` - all args are passed through.`--test FILE` has been added to feed in an existing valgrind log file to colour.Usage as a lib--------------You can also use the filter as a library function, if you're running valgrindfrom another python project.```from colourvalgrind import colour_valgrind...print(colour_valgrind(valgrind_output))```
Package: colour-workbench
Colour WorkbenchThis project can be used as a environment forcolour-developersor for people interested
in developing and exploring colour-science in general.This workbench template installs colour-science, colour-datasets, and
colour-specio into your python environment with are contain useful color
algorithms, data, and spectrometer controls respectively.InstallationTo use this repository you need to install python poetry to manage the
development environment. Poetry can be installed by following the documentationhereAfter installingpoetryopen a terminal into the project directory and runpoetry install. THen open the project folder in vscode.In visual studio code make sure to select the correct python environment and
finally you can start experimenting. A good entry point is to look at theREADMEin the ETD Display Evaluation folder
and then start your own notebooks in thenotebooksfolder.Test Pattern GeneratorThere is a test pattern generator project that may be useful in combination with
this project, details can be found on (its github page)[https://github.com/tjdcs/ETC_TestPatterns].
Package: coloury
ColouryMake your ASCII art beautiful!import coloury

# Example

text = """
  cccc yy   yy   aa aa nn nnn  rr rr    aa aa zzzzz   eee  
cc     yy   yy  aa aaa nnn  nn rrr  r  aa aaa   zz  ee   e 
cc      yyyyyy aa  aaa nn   nn rr     aa  aaa  zz   eeeee  
 ccccc      yy  aaa aa nn   nn rr      aaa aa zzzzz  eeeee 
        yyyyy                                              
"""

output = coloury.purplish(text)

print(output)All cosmetic styles:purplishgrellowgreen_flamescrimsonflamingpinkCheck CIA out onGitHub!
Package: colourz
colourzColourz adds coloured text output and spinners to a Windows shell (Powershell / CMD)Installation$ pipenv install colourzUsageimportcolourz# Print in bold textprint(colourz.bold("Bold text"))# Print text in redprint(colourz.normal("Red text","RED"))# Print text in bold redprint(colourz.bold("Bold red text","RED"))# Use Bullets when waiting on a long taskimporttimedefmain():s=colourz.Bullets()print("Doing long task...")s.start()long_task()s.stop()print("Success!")# CAUTION: As Bullets is threaded, we need to watch out for exceptionsdeflong_task():raiseLongTaskErrordefmain():s=colourz.Bullets()print("Doing long task...")s.start()try:long_task()msg="Success!"exceptLongTaskError:msg="Fail!"finally:s.stop()print(msg)
Package: colrev
Collaborative Literature Reviews (CoLRev)SummaryCoLRev is an open-source environment for collaborative literature reviews. It integrates with differerent synthesis tools, takes care of the data, and facilitates Git-based collaboration.To accomplish these goals, CoLRev advances the design of review technology at the intersection of methods, design, cognition, and community building.
The following features stand out:Supports all literature review steps: problem formulation, search, dedupe, (pre)screen, pdf retrieval and preparation, and synthesisAn open and extensible environment based on shared data and process standardsBuilds on git and its transparent collaboration model for the entire literature review processOffers a self-explanatory, fault-tolerant, and configurable user workflowOperates a model for data quality, content curation, and reuseEnables typological and methodological pluralism throughout the processSee thedocumentationandstatements of development statusfor more details. A brief overview presented at ESMARConf2023 is available onYouTube.Contributing, changes, and releasesContributions, code and features are always welcomeSeecontributing guidelines,help page, andgithub repository.Bug reports or feedback? Please use theissue trackerand let us know.To get your work included, fork the repository, implement your changes, and create apull request.For further information, seetests,changes, andreleases.ContributorsGerit Wagner💻📖🔣🖋💡Julian Prester💻📖🔣🖋🐛🤔Tarin Mahmood💻⚠️📖dengdenglele🔣📖⚠️mhlbrsimon💻ossendorfluca💻katharinaernst💻einfachjessi💻Janus678💻frxdericz💻MalouSchmidt💻RheaDoesStuff💻Cohen2000💻RobertAhr💻ThomasFleischmann💻AntonFrisch💻LouisLangenhan💻📖Peter Eckhardt💻📖User123projekt💻📖LuminousLynx💻📖LicenseThis project is distributed under theMIT Licensethe documentation is distributed under theCC-0license.
If you contribute to the project, you agree to share your contribution following these licenses.Citing CoLRevPleasecitethe project as follows:Wagner, G. and Prester, J. (2024) CoLRev - An open-source environment for Collaborative Literature Reviews. Available athttps://github.com/CoLRev-Environment/colrev.
Package: col-spanish
col-spanishA collection of tools to work with text write in Spanish (Colombia)Purpose of the PackageThe purpose of the package is to create a group of functions that help to work with text in spanish, to be more accurate with spanish from Colombia.Featuresnormalization functions:delete punctuation marksdelete accentsencrypting functions:set_characters:delete duplicate characters inside the sentence. save it in the same order,
as it appears in the sentence not in an aleatory order as set()create_dictionary:Recieves two lists and create a dictionary where one is the key and the
other one is the value.generate_pass:This function create a safe encrypted version of your data.Geting StartedThe package can be found in Pypi, hence you can install it using pippipinstallcol_spanishUsageUsing the normalization function to remove punctuation marks>>>fromcol_spanishimportdel_punctuation>>>del_punctuation('Hola, ¿cómo estas? ¡bien!')>>>Examples>>>fromcol_spanishimportdel_punctuation>>>del_punctuation('Hola, ¿cómo estas? ¡bien!')Holacómoestasbien>>>text="Hola, ¿cómo estas? ¡bien!">>>normalized_text=del_punctuation(text)>>>normalized_textHolacómoestasbienContributionContributions are welcolme.
If you notice a bug let us know, thanks!AuthorMain maintainer: Sergio A. Sosa Bautista (@sergioasb8)
Package: coltrane
coltraneA Dynamic Site Generator that harnesses the power of Django without the hassle 🎵📖 Complete documentation athttps://coltrane.readthedocs.io.📦 Package located athttps://pypi.org/project/coltrane/.⭐ FeaturesRendermarkdownfiles as HTML with automatic URL routing based on the filesystemUse JSON files as data sources in HTML templates ormarkdownAutomatic generation ofsitemap.xmlandrss.xmlfilesCan serve non-markdown files likerobots.txtLocal development server which includeslive re-rendering of markdown and dataviahttps://github.com/adamchainz/django-browser-reloadDeployment best practices withwhitenoiseandgunicornalready configuredLeverage the power of built-inDjangotemplates, template tags, and filters insidemarkdownfilesAny custom template tags and filters are enabled automatically for use inmarkdownor HTML templatesInclude any third-partyDjangoappfor additional functionalityOptional command to generate static HTML filesAble to be integrated into a regularDjangoproject as a standard third-partyDjangoapp⚡ Quick startmkdir new-site && cd new-siteto create a new folderpoetry init --no-interaction --dependency 'coltrane:<1' && poetry installto create a new virtual environment and install thecoltranepackageOptional:brew install watchmanon MacOS for less resource-intensive local development serverpoetry run coltrane createto create the folder structure for a new sitepoetry run coltrane playto start local development serverGo tohttp://localhost:8000to see the original markdown rendered into HTMLUpdatecontent/index.mdGo tohttp://localhost:8000to see the updated markdown rendered into HTMLOptional: runpoetry run coltrane recordto build static HTML filesGeneratedcoltranefile structure.
├──.env
├──.gitignore
├──.watchmanconfig
├──__init__.py
├──app.py
├──content
│└──index.md
├──data
├──Dockerfile
├──gunicorn.conf.py
├──templates
├──poetry.lock
└──pyproject.toml📝 ContentAddmarkdownfiles or sub-directories to thecontentdirectory and rendered HTML will be accessible via auto-generated routes./would render themarkdownincontent/index.md/about/would render themarkdownincontent/about.md/articles/this-is-the-first-article/would render the content from/content/articles/this-is-the-first-article.md/not-there/will 404HTML will also be served automatically if amarkdownfile can not be found./app/would render the HTML from/templates/app.htmlor/templates/app/index.html/app/some-userwould render the HTML from/templates/app/*.htmlDeploymentExampleDockerfileandgunicorn.conf.pyfiles are created when an app is created, and optional dependencies can be installed for efficientstaticserving withwhitenoise.📖 DocumentationRead all of the documentation athttps://coltrane.readthedocs.io.Contributors ✨Thanks goes to these wonderful people (emoji key):Tobi DEGNON⚠️💻This project follows theall-contributorsspecification. Contributions of any kind welcome!
Package: columbia-discord-bot
Columbia Discord BotOverviewA Discord bot that allows users to keep track of and find other students with the same classes and professors.How to add to your Discord serverInvite this bot using thislinkBot Commands!createuser <UNI>- adds a new user to the database!addclass <class>- adds a class to your profile!addprof <professor>- adds a professor to your profile!removeclass <class>- removes a class from your profile!removeprof <professor>- removes a professor from your profile!getclasses <class>- gives you the list of classes you have!getprofs <professor>- gives you the list of professors you haveDownloading and installing this repoYou can check out CONTRIBUTING.md to find out how to fork, clone, and make edits to this bot. You will need your own bot token from Discord along with some other dependencies.
Package: columbo
ColumboSpecify a dynamic set of questions to ask a user and get their answers.columbo's feature set allows a program to:Ask multiple types of questions:Yes or NoMultiple choiceOpen-endedValidate the response provided by the user.Use answers from earlier questions:As part of the text of a questionAs part of the text of a default valueTo decide if a question should be skippedAccept answers from the command line in addition to prompting the user.ExampleUser PromptsThe primary use ofcolumbois to define a sequence of interactions that are used to prompt a user to provide answers
using a terminal. Below is a sample which shows some ways this can be used.importcolumbointeractions=[columbo.Echo("Welcome to the Columbo example"),columbo.Acknowledge("Press enter to start"),columbo.BasicQuestion("user","What is your name?",default="Patrick",),columbo.BasicQuestion("user_email",lambdaanswers:f"""What email address should be used to contact{answers["user"]}?""",default="me@example.com"),columbo.Choice("mood","How are you feeling today?",options={"happy":"😀","sad":"😢","sleepy":"🥱","confused":"🤔",},default="happy",),columbo.Confirm("likes_dogs","Do you like dogs?",default=True),]answers=columbo.get_answers(interactions)print(answers)Below shows the output when the user accepts the default values for most of the questions. The user provides a different
value for the email and explicitly confirms that they like dogs.Welcome to the Columbo example
Press enter to start
 
What is your name? [Patrick]:

What email address should be used to contact Patrick? [me@example.com]: patrick@example.com

How are you feeling today?
1 - 😀
2 - 😢
3 - 🥱
4 - 🤔
Enter the number of your choice [1]:

Do you like dogs? (Y/n): y

{'user': 'Patrick', 'user_email': 'patrick@example.com', 'mood': 'happy', 'likes_dogs': True}Command Line AnswersIn addition to the interactive prompts,columbocan also parse command line arguments for interactions. This is done by
changingcolumbo.get_answers()tocolumbo.parse_args(). Below shows the output when using the same interactions from above.$pythoncolumbo_example.py--user-emailpatrick@example.com--likes-dogs{'user':'Patrick','user_email':'patrick@example.com','mood':'happy','likes_dogs':True}The full exampleimportcolumbointeractions=[columbo.Echo("Welcome to the Columbo example"),columbo.Acknowledge("Press enter to start"),columbo.BasicQuestion("user","What is your name?",default="Patrick",),columbo.BasicQuestion("user_email",lambdaanswers:f"""What email address should be used to contact{answers["user"]}?""",default="me@example.com"),columbo.Choice("mood","How are you feeling today?",options=["happy","sad","sleepy","confused"],default="happy",),columbo.Confirm("likes_dogs","Do you like dogs?",default=True),]answers=columbo.parse_args(interactions)print(answers)DocumentationCheck out theproject documentation.For an overview on how repository structure and how to work with the code base, read theDevelopment Guide.CreditsThe development of this project was originally funded and incubated byWayfair.
Package: columbus
ColumbusWhat is Columbus?Columbus is a Python web framework that automatically generates an async CRUD REST API web application from an SQLAlchemy table.How does it work?Under the hood Columbus usesStarlette,DatabasesandSQLAlchemyalong with some interesting metaprogramming techniques to generate a web app based solely on your YAML specification and SQLalchemy table definition.Installationpip install columbusQuickstartYou can have your API up and running in only a couple of simple steps:startThis command will generate two files for you:
main.yml with a basic config template and an empty models.py.In models.py define your database table using SQLAlchemy.Then create the tables (Alembicis generally the recommended way to do this) and add some data whichever way you like. Columbus doesn't need you to connect to the database or write any queries for the app to work, it will do that for you. All you need to do is provide it with the database url.In main.yml add the database urlas a value for the 'database' key.Add the name of your tableas the value for the 'table' key.Here is a basic working example (provided you've set up the database with this url and your table is named my_table and located in models.py).models: models.py
database: postgresql://someuser:postgres@localhost/mydatabase
APIs:
  hello_world:
    table: my_table
    methods: [GET]runThis command will run your app.Navigate to localhost:8000/my_table and see your API in action.DocumentationHere is a comprehensive list of possible keys and values in the YAML config.Keys:models: relative path to the file where your SQLAlchemy table is defineddatabase: valid database urlAPIs: the APIs you want Columbus to generate. Each API can be named whatever you want, but it has two mandatory keys:table: name of SQLAlchemy table from which you want to generate the APImethods: list of http methods (GET, PUT, POST, DELETE) you want the API to support. Attention: this is the only key that needs to be a list, so put the methods in square brackets.Below is an example of a more comprehensive animals API, which should give you a feel for the correct YAML structure Columbus understands. Incorrect structures will throw an error and the app won't run.models: models.py
database: postgresql://someuser:postgres@localhost/mydatabase
APIs:
  dogs:
    table: dogs
    methods: [GET, POST]
  cats:
    table: cats   
    methods: [GET, POST, PUT, DELETE] 
  snakes:
    table: snakes
    methods: [GET, POST, PUT]   
  bears:
    table: bears
    methods: [GET]What use cases does it support?Columbus is still in the early days of active development, so it only supports the most basic use case for now. Feel free to open an issue for a missing feature and it will most likely be pushed to the top of the priority list and shipped soon.
Package: column
column is a thin wrapper on top of ansible API, to serve
as an entry point for other code when ansible is needed. As ansible
internal API is not officially exposed and thus changes are very likely,
this wrapper should be used instead of touching ansible directly,
so that any further ansible API change will only incur change in this module.It exposes two classes:
column.APIRunner and column.SubprocessRunnerBoth of them implement API described in column.Runner.
Each runner expose two public methods:
run_playbook() and run_module().
Package: columnarframe
ColumnarFrameカラムベースでデータを扱うためのライブラリです。
ある程度Pandasのように操作できるような形を目指しています。This is a library for handling column-based data.
It is intended to be operated like Pandas to some extent.Memounittestpoetry run python -m unittest discoverbuildpoetry buildpublish(Test)poetry publish -r testpypipublic(real)poetry publishlib installpoetry add xxxx
Package: columngenerationsolverpy
Column Generation Solver (Python)A solver based on column generation.This is the Python3 version of the C++ packagefontanf/columngenerationsolver.image sourceDescriptionThe goal of this repository is to provide a simple framework to quickly implement heuristic algorithms based on column generation.Algorithms:Column Generationcolumn_generationGreedygreedyLimited Discrepancy Searchlimited_discrepancy_searchExamplesCutting Stock ProblemUsage, running examples from command lineInstallpip3installcolumngenerationsolverpyRunning an example:mkdir-pdata/cuttingstock/instance
python3-mexamples.cuttingstock-agenerator-idata/cuttingstock/instance
python3-mexamples.cuttingstock-acolumn_generation-idata/cuttingstock/instance_10.json
python3-mexamples.cuttingstock-alimited_discrepancy_search-idata/cuttingstock/instance_10.jsonUpdate:pip3install--upgradecolumngenerationsolverpyUsage, Python librarySee examples.
Package: columnify
columnifyInspired bycolumnify.columnifycreates text-based columnized (ls-like) content suitable for console output from list of strings.Columns are automatically resized to fit the content of the largest cell. Each cell will be padded with spaces to fill the available space and ensure column contents are aligned.Table of ContentsExamplesInstallationAPIMethodsLicenseExamplesitems:list[str]=["Canidae","Felidae","Cat","Cattle","Dog","Donkey","Goat","Guinea pig","Horse","Pig","Rabbit","Fancy rat varieties","laboratory rat strains",]DefaultCanidae  Cat     Dog     Goat        Horse  Rabbit               laboratory rat strains
Felidae  Cattle  Donkey  Guinea pig  Pig    Fancy rat varietiesHorizon firstCanidae     Felidae  Cat  Cattle  Dog                  Donkey                  Goat
Guinea pig  Horse    Pig  Rabbit  Fancy rat varieties  laboratory rat strainscenter()Canidae   Cat     Dog       Goat     Horse         Rabbit        laboratory rat strains
Felidae  Cattle  Donkey  Guinea pig   Pig   Fancy rat varietiesrjust()Canidae     Cat     Dog        Goat  Horse               Rabbit  laboratory rat strains
Felidae  Cattle  Donkey  Guinea pig    Pig  Fancy rat varietiesCustom delimiter ( | )Canidae | Cattle | Goat       | Pig                 | laboratory rat strains
Felidae | Dog    | Guinea pig | Rabbit
Cat     | Donkey | Horse      | Fancy rat varietiesIndent (4 spaces):Canidae  Cattle  Goat        Pig                  laboratory rat strains
    Felidae  Dog     Guinea pig  Rabbit
    Cat      Donkey  Horse       Fancy rat varietiesSeeexamples/example.pyfor more information.Installationpip install columnifyAPIMethodsdefcolumnify(items:list[str],line_width:int,indent:int=0,delimiter:str='  ',align_func_name:str='ljust',horizon_first:bool=False)->str:...Licensecolumnifyis distributed under the terms of theMPL-2.0license.