Saravanan666/pypi-org huggingface dataset:
Package: palatable
PalatableA Fast, reliable Exam Scheduling Algorithm Using Graph Coloring.AboutThis package presents a graph-coloring-based algorithm for the exam scheduling application, with the objective of achieving fairness, accuracy, and optimal exam time period. Through the work, we consider few assumptions and constraints, closely related to the general exam scheduling problem, and mainly driven from accumulated experience at various universities. The performance of the algorithm is also a major concern of this package.Getting startedpipinstallpalatableUsageThe simplest way to use the package is using this command.palatable-dfiles/schedule.txt-cfiles/courses.txtFor a list of all available optionspalatable-h

usage:palatable[-h][--slotsSLOTS][--daysDAYS][--fairnessFAIRNESS]--scheduleSCHEDULE--coursesCOURSES

optionalarguments:-h,--helpshowthishelpmessageandexit--slotsSLOTS,-sSLOTSNumberofexamtimeslotsinagivenday(determinedbytheregistrarand/orthefaculty)--daysDAYS,-yDAYSThenumberofconcurrentexamsessions.Boundedbyavailablehalls,andtheavailabilityoffacultytoconducttheexams.--fairnessFAIRNESS,-fFAIRNESSAnExamscheduleshouldavoidconflicts,inthesensethatnotwoormoreexams(thisvalue)forthesamestudentarescheduledatthesametime.--scheduleSCHEDULE,-dSCHEDULEThepathofthefileforstudents' enrollments.--courses COURSES, -c COURSESThe path of the file that hosts courses'data.UpcomingWe are currently supporting text formatted courses and schedules tables. CSV support is coming up soon.ReferencesThis package is an implementation of the algorithm presented in the paper:A New Exam Scheduling Algorithm Using Graph ColoringbyMohammad Malkawi,Mohammad Al-Haj Hassan, andOsama Al-Haj Hassan.
Package: palavreco
PalavrecoEste é um jogo para terminal baseado noWordle,TermoeLetreco.InstalaçãoInstale com pip ou seu gerenciador de pacotes PyPI favorito.pipinstallpalavrecoExecutando o jogoExecute o seguinte comando no seu terminal:palavrecoNoTermovocê deve acertar uma palavra em6tentativas. NoDuetosão duas palavras em7tentativas.A palavra sempre terá 5 letras, e será gerada de forma aleatória a partir de uma lista preestabelecida.Depois de cada tentativa, as letras recebem cores para mostrar o quão perto você está da solução.
Somente palavras existentes são aceitas por tentativa.Caso a letra fiquevermelha, significa que elanão faz parte da solução.Caso a letra fiqueverde, significa que elafaz parte da solução e está na posição correta.Caso a letra fiqueamarela, siginifica que elafaz parte da solução porém em outra posição.As palavras podem possuir letras repetidas.
Ao observar as cores das letras você pode verificar se uma mesma letra se repete na palavra ou não.Os acentos são preenchidos automaticamente e não são considerados nas dicas.Como funcionaAs palavras selecionadas para as partidas foram escolhidas manualmente por mim, e em cada início de partida uma nova palavra é escolhida aleatoriamente.Para verificar se a palavra existe ou não, filtrei uma lista publica de palavras que pode ser encontradaaqui, e coloquei essas palavras em um database, com cada palavra acentuada e desacentuada.Para verificar a existência de cada palavra realizei requests nodicio.com, onde fiz um script em python para automatizar o processo.
Package: palazzetti-sdk-asset-parser
Palazzetti SDK - Asset ParserLibrary to detect capabilities of Palazzetti's product based on static and dynamic dataRequires Python 3.6 and uses semver.importpalazzetti_sdk_asset_parseraspsapdefmain():asset_parser=psap.AssetParser(get_alls={"STATUS":0},get_stdt={"FAN2TYPE":3})asset_capabilities=asset_parser.parsed_dataif(asset_capabilities.flag_has_fan):print("Product has main fan")if(asset_capabilities.value_product_is_on):print("Product is ON!")else:print("Product is OFF!")main()
Package: palazzetti-sdk-local-api
Palazzetti SDK - Local HUBLibrary to interact with Palazzetti product via LOCAL HTTP HUBRequires Python 3.6 and uses palazzetti-sdk-asset-parser to detect product capabilities.importasynciofrompalazzetti_sdk_local_apiimportHubdefmain():loop=asyncio.get_event_loop()use_ip="192.168.20.94"hub=Hub(use_ip)print("----- BEFORE UPDATE -----")print(f"ID Hub:{hub.hub_id}")print(f"Online:{hub.hub_online}")print(f"BioCC:{hub.hub_isbiocc}")print(f"Product Online:{hub.product_online}")print("Attributes:")print(hub.get_attributes())# now update the hub without discovery only via UDP (deep=False)print(f"Please wait, checking Hub at{use_ip}...")loop.run_until_complete(hub.async_update(discovery=False,deep=False))print("----- POST UPDATE -----")ifhub.hub_online:print(f"Online:{hub.hub_online}")print(f"Label:{hub.label}")print(f"ID Hub:{hub.hub_id}")print(f"BioCC:{hub.hub_isbiocc}")print("Attributes:")print(hub.get_attributes())ifhub.product_online:print(f"Product Online:{hub.product_online}")# now update the hub with discovery and HTTP failover if UDP fails (deep=True)print(f"Please wait, discovering product details for Hub{hub.hub_id}...")loop.run_until_complete(hub.async_update(discovery=True,deep=True))ifhub.productandhub.product.online:print(f"ID Product:{hub.product.product_id}")print("Product Capabilities:")print(hub.product.get_data_config_json())print("Product Attributes:")print(hub.product.get_prod_data_json())return# this should neve happen...print("Product should be online but has not been initiated")returnprint("Hub is online but no Product found")returnprint("Hub offline")
Package: paleomix
The PALEOMIX pipelines are a set of pipelines and tools designed to aid the rapid processing of High-Throughput Sequencing (HTS) data: The BAM pipeline processes de-multiplexed reads from one or more samples, through sequence processing and alignment, to generate BAM alignment files useful in downstream analyses; the Phylogenetic pipeline carries out genotyping and phylogenetic inference on BAM alignment files, either produced using the BAM pipeline or generated elsewhere; and the Zonkey pipeline carries out a suite of analyses on low coverage equine alignments, in order to detect the presence of F1-hybrids in archaeological assemblages. In addition, PALEOMIX aids in metagenomic analysis of the extracts.The pipelines have been designed with ancient DNA (aDNA) in mind, and includes several features especially useful for the analyses of ancient samples, but can all be for the processing of modern samples, in order to ensure consistent data processing.Installation and usageDetailed instructions can be found in thedocumentationfor PALEOMIX. For questions, bug reports, and/or suggestions, please use theGitHub trackeror contact Mikkel Schubert atMikkelSch@gmail.com.CitationsThe PALEOMIX pipelines have been published in Nature Protocols; if you make use of PALEOMIX in your work, then please citeSchubert M, Ermini L, Sarkissian CD, Jónsson H, Ginolhac A, Schaefer R, Martin MD, Fernández R, Kircher M, McCue M, Willerslev E, and Orlando L. “Characterization of ancient and modern genomes by SNP detection and phylogenomic and metagenomic analysis using PALEOMIX”. Nat Protoc. 2014 May;9(5):1056-82. doi:10.1038/nprot.2014.063. Epub 2014 Apr 10. PubMed PMID:24722405.The Zonkey pipeline has been published in Journal of Archaeological Science; if you make use of this pipeline in your work, then please citeSchubert M, Mashkour M, Gaunitz C, Fages A, Seguin-Orlando A, Sheikhi S, Alfarhan AH, Alquraishi SA, Al-Rasheid KAS, Chuang R, Ermini L, Gamba C, Weinstock J, Vedat O, and Orlando L. “Zonkey: A simple, accurate and sensitive pipeline to genetically identify equine F1-hybrids in archaeological assemblages”. Journal of Archaeological Science. 2017 Feb; 78:147-157. doi:10.1016/j.jas.2016.12.005.
Package: palett
palettpretty text for command lineUsagefrompalett.fluo.fluo_vectorimportfluo_vectorfrompalett.presetsimportFRESH,PLANETvectorCollection=[[],['Xx','Yy','Zz','e','d','c','-','1',2,3],[1,1,2,3,5,[]],['a','b','c','d','e'],['beijing','shanghai','wuhan','xiamen','changsha']]deftest():COMMA_SPACE=', 'forvecinvectorCollection:fluoed=fluo_vector(vec,(FRESH,PLANET))print(f'[{COMMA_SPACE.join(fluoed)}]')test()
Package: palette
Authors:Mike SpindelVersion:0.2Palette makes it easy to perform simple operations on colors and to
convert between different color systems and representations.Sample UsageInitialize a color object using whatever representation is convenient:>>> c = Color("#0a0bcc")
>>> c = Color.from_rgb(255, 255, 255, a=0.5)
>>> c = Color(hls=(0.2, 0.1, 0.1))Manipulate colors:>>> a = Color("#aaaa00")
>>> a.lighter()
>>> a.darker(amt=0.4)Measure Colors:>>> a = Color("#aaaa00")
>>> b = Color("#000000")
>>> a.w3_contrast_ratio(b)
>>> a.w3_contrast_test(b)
>>> a.luminanceConvert Representations:>>> a = Color("#aaaa00")
>>> a.rgb8.r
170
>>> a.rgb8.r = 30
>>> tuple(a.rgb8)
(30.0, 170.0, 0.0)
>>> tuple(a.hls)
(0.30392156862745096, 0.3333333333333333, 1.0)
>>> str(a.hls)
'hls(0.30392156862745096, 0.3333333333333333, 1.0)'
>>> a.hex
'#1eaa00'
>>> a.css
'rgb(170, 170, 0)'Convert sRGB:>>> a = Color("#aaaa00")
>>> a.workspace
"srgb"
>>> a.rgb == a.srgb
True
>>> a.linear_rgb
{'r': 0.4019777798321958, 'b': 0.0, 'g': 0.4019777798321958}
>>> a.linear_rgb = (.2, .3, .3)
>>> a.rgb
(0.48452920448170694, 0.5838314900602575, 0.5838314900602575)Where Does Palette Fit In?There already exist several good python libraries for manipulating
color.  Perhaps the two most notable are Grapefruit and
python-colormath.  Palette hopes to fill a niche somewhere between the
two.With respect to grapefruit, palette intends to have:a simpler interface for common tasksmore sophistication with respect to RGB working spaces, illuminants,
etc.PEP-8 complianceWith respect to python-colormath, palette intends to have:a simpler interface for common tasks; potentially at the expense of
deep support for non-RGB colors.more utilities that are primarily useful for web developmentsupport forfewercolorspaces.  Palette isn’t particularly
interested in completionism.no dependency on numpy
Package: palettecleanser
Palette CleanserWe all know that refreshing sensation of setting our desktop applications to a
delicious color scheme such asDraculaorNord. But even the tastiest of color schemes can
grow bland after awhile, leaving you craving a new flavor for your desktop apps.Palette Cleanser provides a means for storing your configuration files as
templates and your color palettes as deployable desktop themes so that you can
avoid the hassle of manually editing hex codes when switching your
applications to a new color scheme.RequirementsPython 3.9+DependenciesJinja2 3.0.1+numpy 1.21.1+pywal 3.3.0+PyYAML 5.4.1+tabulate 0.8.9+typer 0.3.2+InstallationInstall Palette Cleanser with pip:$pipinstall[--user]palettecleanserDocumentationCheck out thewikifor detailed documentation.QuickstartCreate a template:$pcleantemplatecreate.config/alacritty/alacritty.ymlCreate a theme:$pcleanthemegenerate--from-imagepath/to/image--namemy-clean-themeDeploy a theme:$pcleanthemedeploymy-clean-theme--template.config/alacritty/alacritty.ymlLicenceThis project is licensed under the terms of the MIT Licence.
Package: palette_detect
Image palette detection in Python modelled after Paul Annesley’s color
detector in PHP.palette_detectdetermines what the most important colors
used in your image are, and if one of them is a background color.by Dennis Hotson & Lars YenckenUsagepalette_detectis meant to run in a streaming manner. You can run it on a single image by echo’ing in the image:$ echo myimage.png | palette_detect
myimage.png #3e453f,#2ea3b7,#bee6ea,#51544c,#373d38 #ffffffEach input line should be a filename. Each output line will be a tab-delimited
string containing the filename, major colors in order, and (optionally) a
detected background color.To run on an entire directory tree of images:$ find . -name '*.jpg' | palette_detectpalette_detecthas an experimental multiprocessing mode, accessed by the-nargument. For example, to run the same example using 8 processes:$ find . -name '*.jpg' | palette_detect -n 8You can also get usage information by runningpalette_detect –help.
Package: palettepal
PalettepalGenerate color palettes from your terminal.Install with:pip install palettepalAnd run from the command line:python -m palettepalPalettepal requires textual and pyperclip.UsageUse the arrow keys to move the color slider position. Holdshiftwhile using arrow keys to move it faster.Color values may be entered directly into the HSL, RGB, Hex, or Name boxes. These entries are disabled inHSL (RYB Space)because not all RGB colors are mappable to Red-Yellow-Blue colors.Change the color palette selection to display complementary colors using a few defined schemes. The function keys change which color values are displayed in the Input boxes, but the sliders only control the first base color of the palette. Using thecustompalette allows the sliders to change the selected color in the palette.PressR,H, orXto copy the RGB, HSL, or Hex value to the system clipboard (via pyperclip) for use in other applications.
Package: palettetown
Palletetown is a python library that makes it easy to style matplotlib plots using a color palettes based on pokemon.You can use palletetown to:set global matplotlib settings based on a pokemon,set a colormap for a pokemon,set a color cycler for a pokemon,draw a pokemon sprite,get RGB color values from the sprite.The easiest way to get started with palettetown is the set_rc command:import palletetown.pokeplot as pkp

pkp.set_rc('pikachu')This will set the colors of your plot to match the colors of the pokemon.
It workes by setting the prop_cycle and cmap matplotlib rc parameters.Check out theexamples.ipynbjupyter notebook for usage examples.The pokeplot module handles high-level user interactions.
Check out the jupyter notebook on our homepage for examples,
or try these pokeplot features with your own plots.import matplotlib.pyplot as plt
import numpy as np
import palletetown.pokeplot as pkp

# Get a colormap with colors set based on the pokemon sprite
cmap = pkp.get_cmap('pikachu')

# Use it with whatever plot you are working on.
data = np.random.random((10,10))
plt.imshow(data, cmap=cmap)

# Draw a pikachu sprite in the top right corner.
pkp.draw_sprite()

plt.show()

# The default colormap can be set.
pkp.set_rc('pikachu')Pokemon and Pokedex objects can be manipulated directly for advanced use cases.
A Pokemon object contains color data related to that pokemon.
Pokedex objects are dictionary-like containers for Pokemon objects.pikachu = pkp.get_pokemon('pikachu')
# matplotlib linear segmented colormap
cmap = pikachu.cmap
# color cycler
cycler = pikachu.cycler
# image of the pokemon as an ndarray
sprite = pikachu.sprite
# list of rgb colors as 8 bit integers
colors_int = pikachu.rgb_int
# list of rgb colors as floats normalized from 0. to 1.
colors_float = pikachu.rgb_float
# list of rgb colors as hex strings
colors_hex = pikachu.rgb_hex
Package: palettify
palettify - Apply color palettes to images within secondsRequirementsYou will need eitherpilloworpillow-simd. The latter might give a performance boost, however it does not support as many architectures.InstallationThe installation itself is quite easy, simply run:pip install palettifyDidn't work?pipis not inPATHpython-mpipinstallpalettifyCheck if the path of your python executable matches the path of the interpreter you run your code withIn UNIX-like systems:whichpythonUsageYou can use either the command-line or the python API to palettify an image.Through the command-line:
Invoke palettify usingpalettifyorpython -m palettify.paths [paths ...] (required)You can input multiple images, each one pointing to an existing file. A list of supported image formats can be foundhere.-p/--palette (required)The color palette to use. If an integern, palettify will try to find thenmost dominant colors in the original image and build the palette using those colors. Otherwise, a path to a JSON file should be specified, containing a list of RGB channels.[[255,255,255],[0,0,0],[0,255,0],[255,255,0]]-o/--output (optional)If more than one input path is given, the output pathhasto be an existing directory. If only one input path is given, the output path can be either a directory or the path to a file. If no output path is given, palettify will create path duplicates of the input paths and add a-palettifiedsuffix.-a/--autoscale (optional)If autoscale is enabled, palettify tries to find the desktop resolution and resizes the image accordingly, while keeping the original ratio. A display server is required Defaults toFalse.-w/--width (optional)The width of the palettified image. If-h/--heightis not given, palettify will calculate the height to keep the original ratio.-H/--height (optional)The height of the palettified image. If-w/--widthis not given, palettify will calculate the width to keep the original ratio. If neitherwidthorheightare given, palettify will use the resolution of the original image.-t/--threads (optional)The number of threads to start for a single image. Defaults to10.-v/--verbose (optional)Whether to explain what is being done. Defaults toFalse.Invoking palettify through pythonfrompalettifyimportpalettify_imagepalettify_image(...)You can pass in the same arguments as in the command-line. However, optional arguments are keyword-only.
Package: palettipy
InstallationExampleAdding a paletteSingleVariantsMatch the colors of an image to a paletteInstallationpipinstallpalettipyExampleexample.pyimportosimportsysimporttimefromPILimportImagefrompalettipyimportpalettes_loader,palettipy_imagefrompalettipy.paletteimportPalettedefmain(args:list[str],palettes_path:str="palettes"):iflen(args)<=0orlen(args)>=3:print("Usage: example.py path/to/image [palette name]")sys.exit(1)print(args)image_path=args[0]ifnotos.path.exists(image_path):print(f'Image "{image_path}" does not exist')sys.exit(1)palettes=palettes_loader.load_palettes(palettes_path)palette_name=palettes[0].nameiflen(args)>1:palette_name=args[1]ifpalette_namenotin[_p.namefor_pinpalettes]:print(f'Palette "{palette_name}" does not exist')sys.exit(1)start=time.time()palette:Palette=list(filter(lambdap:(p.name==palette_name),palettes))[0]image=Image.open(image_path)image_result=Image.fromarray(palettipy_image(palette,image))image_result.save("output.png")palette.log(f"Done in{(time.time()-start):.3f}s")sys.exit(0)if__name__=="__main__":main(sys.argv[1:])pythonexample.pypath/to/image"Catppuccin Mocha"Adding a paletteSingleTo add a new palette, simply create a file inpalettesdirectory like belowRainbow.txt#ff6b6b#ffd93d#6bcb77#4d96ffVariantsIf you have multiple variants of a palette, just create a subfolder underpaletteswith all its variants in itRainbow/Pastel.txt#ff6b6b#ffd93d#6bcb77#4d96ff
Package: palgen
# Palgen[![PyPI](https://img.shields.io/pypi/v/palgen.svg)](https://pypi.org/project/palgen/)
[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/your_username/palgen/blob/main/LICENSE)
[![Documentation](https://img.shields.io/badge/Documentation-palgen.palliate.io-brightgreen)](https://palgen.palliate.io)Palgen is a powerful and modular command line tool aiming to simplify writing various common utilities such as build scripts, code generators and preprocessors. Palgen provides an easy-to-use interface for creating command line applications by automatically generating command line interfaces (CLIs) from pydantic schemas. This allows for file-based configurations and setting validation.## FeaturesEasily extendible. Once your user provided class inherits from palgen’sExtensioninterface it will be recoginized as extension and become runnable.Automatic generation of command line interfaces.Settings validation using pydantic.Easy migration from existing Python projects.Easy-to-use ingest pipelines for processing data.Automatic parallelization of extension pipelines unless disabled.Comprehensive documentation available at [palgen.palliate.io](https://palgen.palliate.io).## InstallationPalgen can be installed via pip:`shell pip installgit+https://github.com/palliate/palgen.git@master`For now it is necessary to pull it from git directly. A proper release will soon follow.## DocumentationThe detailed documentation for palgen can be found at [palgen.palliate.io](https://palgen.palliate.io). It includes guides, examples, and API reference documentation to help you get started and make the most out of palgen.## ExamplesCheck out the [examples](https://github.com/palliate/palgen/tree/master/examples) subfolder in the repository for various usage examples for palgen.Palgen itself uses palgen to generate parts of its documentation. You can check out those more complex extensions in the [docs/modules](https://github.com/palliate/palgen/tree/master/docs/modules) subfolder. Since this project is part of the [palliate](https://palliate.io) project you may find additional usage examples in the other repositories within the [palliate organization](https://github.com/palliate).## ContributingContributions to palgen are very welcome! If you find any issues or have suggestions for improvements, please open an issue on the [GitHub repository](https://github.com/palliate/palgen). You can also submit pull requests with bug fixes or new features.Before making a contribution, please ensure that you have read and understood the [Contributing Guidelines](https://github.com/palliate/palgen/blob/main/CONTRIBUTING.md).## Community and SupportJoin the palliate Discord server to connect with the community and get support for palgen and other palliate projects. [Join here](https://discord.palliate.io).## LicensePalgen is licensed under the MIT License. See the [LICENSE](https://github.com/palliate/palgen/blob/master/LICENSE) file for more details.
Package: palgoviz
palgoviz - Materials for Python and algorithms, with visualizationpalgovizis a project to develop approaches and materials for teaching and
learning Python together with algorithms and data structures, with a
substantial component of visualization.This package is not most of palgoviz.Most users of palgoviz should clonethe palgoviz GitHub repositoryinstead. That page includes instructions. You most likely willnotwant to
install palgoviz withpipor have it as a dependency of another project, but
it is for those rather special situations that this PyPI package exists.Because of palgoviz’s educational nature, its unit tests and Jupyter notebooks
are important in most uses. This package omits them, as well as most
documentation. Furthermore, the main use for palgoviz, as detailed further in
the repository readme, is as a source of exercises (which may require
modification for your needs) or of ideas for them. In that use, installing this
very limited palgoviz package does not help at all.Depending on the direction of the project, it is possible that, in the future,
more reasons to install palgoviz as a library will arise. For now, that is a
niche use, andthe palgoviz GitHub
repositoryis the recommended way to
read about, and obtain, palgoviz.palgoviz is licensed under0BSD, a
“public-domain equivalent” license.
Package: pali
PaliPali is a simple Thread Pool library for Python. It is compatible with Python3 as well as Python2.Pali can be used for:Creating Data Pipelines.Handling requests in Messaging Brokers (on the top of TCP/IP layer).Simulating any stress testing systems.API Testing systems.UsagePali is simple to use. Pali's Worker Pool works on tasks with well defined interface inpali.task.Task.
New Tasks can be extended from it as following._runmethod is important and mandatory to define as the
Thread Pool internally looks and invokes this function as start of the task.>>>frompaliimportworker,task>>>classMyTask(task.Task):...def__init__(self,ident):...self.task_id=ident...self.done=False......def_run(self):...self.done=TrueThread Pool in itself can work either as context manager or can be invoked manually. Example below shows it's use
as context manager.# create 10 tasks>>>tasks=[MyTask(i)foriinrange(10)]# Start a Thread Pool with 3 thread and push tasks on it.# Tasks are processed as and when they come.>>>withworker.ThreadPool(3)astpool:..._=[tpool.append_task(t)fortintasks]# Check the status of Tasks>>>status=[t.donefortintasks]>>>status[True,True,True,True,True,True,True,True,True,True]Further examples can be found athttps://github.com/gitvipin/Pali/tree/master/teststhat reflect different ways of using ThreadPool.RequirementsPython 2.7+ and Python 3.4+Share and enjoy!