Saravanan666/pypi-org huggingface dataset:
Package: palindrome-tree
Palindrome treePalindrome tree tool is used for analyzing inverted repeats in various DNA sequences using decision trees. This tool takes provided sequences and finds interesting parts in which there's high probability of palindrome occurrence using decision tree. This process filters a big portion of data. Interesting data are then analyzed using API fromPalindrome Analyzer. DNA Analyser is a web-based server for nucleotide sequence analysis. It has been developed thanks to cooperation of Department of Informatics, Mendel’s University in Brno and Institute of Biophysics, Academy of Sciences of the Czech Republic.RequirementsPalindrome tree was built with Python 3.7+.InstallationTo install palindrome tree usePypirepository.pip install palindrome-treeUsageUser has to initialize palindrome tree analyzer instance which is imported from main packagepalindrome_tree.frompalindrome_treeimportPalindromeTreetree=PalindromeTree()Predict regions (without API validation)To predict regions with possible palindromes, run analyse without settingcheck_with_apiparamether.frompalindrome_treeimportPalindromeTreesequence_file=open("/path/to/sequence/name.txt","r")tree=PalindromeTree()tree.analyse(sequence=sequence_file.read(),)tree.resultsThe results are then stored in results variable aspd.DataFrame.positionsequence08TTTGTAGAGACAGGGTCTTGCTGTGTTTCC110TGTAGAGACAGGGTCTTGCTGTGTTTCCCA249CGAACTCCTGGCCTCTAGGCAATCCTCCCA3102ATCCCACTCTTTTTTGAAAAATAAAATCTA4105CCACTCTTTTTTGAAAAATAAAATCTACCAPredict regions (with API validation)To predict regions with possible palindromes and afterward validation, run analyse withcheck_with_apiparamether set.frompalindrome_treeimportPalindromeTreesequence_file=open("/path/to/sequence/name.txt","r")tree=PalindromeTree()tree.analyse(sequence=sequence_file.read(),validate_with_api=True,)tree.validated_resultsThe results are also stored in results variable aspd.DataFrame.original_indexafterbeforemismatchesoppositepositionsequencesignaturespacerstability_NNModel00CCTTTGT2CTGTGTTT5AGAGACAG8-7-2GGTCTTG{'cruciform': -5.74, 'linear': -27.590000000000003, 'delta': 21.85}10TGCTGTTTGT2GGGTCT5AGAGAC6-1-2A{'cruciform': -2.54, 'linear': -13.84, 'delta': 11.3}20GTGTTTGTAG2CTTGCT7AGACAG6-3-2GGT{'cruciform': -1.94, 'linear': -17.509999999999998, 'delta': 15.569999999999999}30TTCCTAGAG2CTGTGT9ACAGGG6-5-2TCTTG{'cruciform': -3.7399999999999998, 'linear': -20.99, 'delta': 17.25}41CCCATGT2CTGTGTTT3AGAGACAG8-7-2GGTCTTG{'cruciform': -5.74, 'linear': -27.590000000000003, 'delta': 21.85}Dependenciesxgboost = "^1.5.1"pandas = "^1.3.5"scikit-learn = "^1.0.2"requests = "^2.26.0"AuthorsPatrik Kaura-Main developer-patrikkauraJaromir Kratochvil-Developer-jaromirkratochvilJiří Šťastný-SupervisorLicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: palindromus
Palindromus documentationSee athttps://palindromus.readthedocs.ioOverwiewPackage helps you to check that any string, word or text are palindrome.CheckingCheck any strings:from palindromus import *

somestr = """ÐÐ¾Ð¹ Ð¸ Ð²ÐµÑÐ° - ÑÐ°Ð½Ñ Ñ Ð¡Ð¸Ð¾Ð½Ð°
Ð½Ð¾ ÐÑÑÑ Ð½Ð° ÑÐ°ÑÐµ - ÐÐ¸Ð¹Ð¾Ð½"""

r = check(somestr)
print(r) # TrueCheck any words:from palindromus import *

someword = "ÑÐ¾Ð¿Ð¾Ñ"

r = check(someword, check = WORD)
print(r) # TrueCheck any multiline palindrome:from palindromus import *

somemultiline = """ÐÐ´ - Ð¶Ð°Ð¶Ð´Ð°!
ÐÐ´ - Ð¶Ð°Ñ, Ð²ÑÐ°Ð¶Ð´Ð°!
ÐÐ´ Ð³Ð¾Ð½Ð¸Ñ Ð¸Ð½Ð¾Ð³Ð´Ð°."""

r = check(somemultiline, check = MULTILINE)
print(r) # TrueCheck any text:from palindromus import *

sometext = """Ð¯ Ð½ÐµÐ¼ Ð¸ ÑÐ°Ð´ Ñ,
ÑÐ°Ðº, ÑÑÐ°Ð¼Ð²Ð°Ð¹,
ÑÐ½Ð²Ð°ÑÑ ÑÐ°Ð²Ð½ÑÐ¹,
Ð° Ð² Ð¼Ð°ÑÑ ÐºÐ°ÑÑ,
Ð´Ð°ÑÐ¸ Ð¼ÐµÐ½Ñ."""

r = check(sometext, check = TEXT)
print(r) # TrueCheck any superpalindrome:from palindromus import *

sometext = "Nora. Omar. Ramo. Aron"

r = check(sometext, check = SUPER)
print(r) # TrueGlobal settingsYou can use global variabliesSTRING,WORD,TEXT,MULTILINE,SUPERfor
checking any your strings as string, word, text, multiline palindrome or superpalindrome.You can use dictionaries of interchangeable letters (ALL,RUSSIAN,LATIN) for interchange.
Package: palladio
# palladio
ParALleL frAmework for moDel selectIOn### Welcome to PALLADIO.
PALLADIO is a machine learning framework whose purpose is to provide robust and reproducible results when dealing with data where the signal to noise ratio is low; it also provides tools to determine whether the dataset being analyzed contains any signal at all.
PALLADIO works by repeating the same experiment many times, each time resampling the training and the test set so that the outcome is reliable as it is not determined by a single partition of the dataset. Besides, using permutation tests, a measure of how much experiments produce a reliable result is provided.
Since all experiments performed are independent, PALLADIO is designed so that it can exploit a cluster where it is available.### Dependencies
PALLADIO is developed using Python 2.7 and inherits its main functionalities from:
* numpy
* scipy
* scikit-learn
* mpi4py
* matplotlib
* seaborn### Authors and Contributors
Current developers: Matteo Barbieri (@matteobarbieri), Samuele Fiorini (@samuelefiorini) and Federico Tomasi (@fdtomasi).### Support or Contact
Having trouble with PALLADIO? Check out our [documentation](http://slipguru.github.io/palladio/) or contact us:
* matteo [dot] barbieri [at] dibris [dot] unige [dot] it
* samuele [dot] fiorini [at] dibris [dot] unige [dot] it
* federico [dot] tomasi [at] dibris [dot] unige [dot] it
Package: palladium
PalladiumPalladium provides means to easily set up predictive
analytics services as web services.  It is apluggable frameworkfor developing real-worldmachine learning solutions.  It provides
generic implementations for things commonly needed in machine
learning, such as dataset loading, model training with parameter
search, a web service, and persistence capabilities, allowing you to
concentrate on the core task of developing an accurate machine
learning model.  Having a well-tested core framework that is used for
a number of different services can lead to a reduction of costs during
development and maintenance due to harmonization of different services
being based on the same code base and identical processes. Palladium
has a web service overhead of a few milliseconds only, making it
possible toset up services with low response times.Aconfiguration filelets you conveniently tie together existing
components with components that you developed.  As an example, if what
you want to do is to develop a model where you load a dataset from a
CSV file or an SQL database, and train an SVM classifier to predict
one of the rows in the data given the others, and then find out about
your model’s accuracy, then that’s what Palladium allows you to dowithout writing a single line of code. However, it is also
possible to independently integrate own solutions.Much of Palladium’s functionality is based on thescikit-learnlibrary.  Thus, a lot of times you will find yourself looking at thedocumentation for scikit-learnwhen
developing with Palladium.  Although being implemented in Python,
Palladium provides support for other languages and is shipped with
examples how tointegrate and expose R and Julia models.For an efficient deployment of services based on Palladium, a script tocreate Docker images automaticallyis provided. In order to manage
and monitor a number of Palladium service instances in a cluster,Mesosphere’s Mesos framework Marathon can be used for deployment,
also enablingscalability by having a variable number of service
nodes behind a load balancer.  Examples how to create Palladium
Docker images and how to use them with Mesos / Marathon are part of
the documentation. Other important aspects – especially relevant in
enterprise contexts for setting up productive services – likeauthentication, logging, or monitoring, can be easily integrated via
pluggable decorator listsin the configuration file of a service,
keeping track of service calls and corresponding permissions.Everyone is welcome to contribute to Palladium. More information on
how to to contribute can be found in the FAQ section of thePalladium documentation.LinksSource code repository at GitHub:https://github.com/ottogroup/palladiumDocumentation including installation instructions and tutorial:http://palladium.readthedocs.orgMailing list:https://groups.google.com/forum/#!forum/pld-listMaintainer:Andreas Lattner
Package: pallas
Pallas makes querying AWS Athena easy.It is especially valuable for analyses in Jupyter Notebook,
but it is designed to be generic and usable in any application.Main features:Friendly interface to AWS Athena.Caching - local and remote cache for reproducible results.Performance – Large results are downloaded from S3.Pandas integration - Conversion to DataFrame with appropriate dtypes.Optional white space normalization for better caching.Kills queries on KeyboardInterrupt.importpallasathena=pallas.environ_setup()df=athena.execute("SELECT 'Hello world!'").to_df()Pallas is hosted atGitHuband
it can be installed fromPyPI.DocumentationDocumentation in thedocs/directory can be read online
atRead the Docs.ChangelogChangelog is theCHANGELOG.rstfile. It is also availableonline in docs.LicenseCopyright 2020 Akamai Technologies, Inc

Licensed 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 at

    http://www.apache.org/licenses/LICENSE-2.0

Unless 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.ContributingBy submitting a contribution (the “Contribution”) to this project,
and for good and valuable consideration, the receipt and sufficiency of which
are hereby acknowledged, you (the “Assignor”) irrevocably convey, transfer,
and assign the Contribution to the owner of the repository (the “Assignee”),
and the Assignee hereby accepts, all of your right, title, and interest in and
to the Contribution along with all associated copyrights, copyright
registrations, and/or applications for registration and all issuances,
extensions and renewals thereof (collectively, the “Assigned Copyrights”).
You also assign all of your rights of any kind whatsoever accruing under
the Assigned Copyrights provided by applicable law of any jurisdiction,
by international treaties and conventions and otherwise throughout the world.
Package: palletier
palletierPalletier is a Python implementation of the solution for the distributer’s
pallet packing problem presented by Erhan Baltacioğlu in his thesisThe distributer’s three-dimensional pallet-packing problem: a human intelligence-based heuristic approachfound here.Free software: MIT licenseDocumentation:https://palletier.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-02-27)First release on PyPI.
Package: palletjack
PalletJackPalletJack was created as a workaround for apache/arrow#38149. The standard parquet reader is not efficient for files with numerous columns and row groups, as it requires parsing the entire metadata section each time the file is opened. The size of this metadata section is proportional to the number of columns and row groups in the file.PalletJack reduces the amount of metadata bytes that need to be read and decoded by storing metadata in a different format. This approach enables reading only the essential subset of metadata as required.FeaturesStoring parquet metadata in an indexed formatReading parquet metadata for a single row groupReading parquet metadata for multiple row groupsRequired:pyarrow  ~= 15.0PalletJack operates on top of pyarrow, making it an essential requirement for both building and using PalletJack. While our source package is compatible with recent versions of pyarrow, the binary distribution package specifically requires the latest major version of pyarrow.Installationpip install palletjackHow to use:Generating a sample parquet file:import palletjack as pj
import pyarrow.parquet as pq
import pyarrow as pa
import numpy as np

row_groups = 200
columns = 200
chunk_size = 1000
rows = row_groups * chunk_size
path = "my.parquet"

data = np.random.rand(rows, columns)
pa_arrays = [pa.array(data[:, i]) for i in range(columns)]
column_names = [f'column_{i}' for i in range(columns)]
table = pa.Table.from_arrays(pa_arrays, names=column_names)
pq.write_table(table, path, row_group_size=chunk_size, use_dictionary=False, write_statistics=False, store_schema=False)Generating the indexed metadata file:index_path = path + '.index'
pj.generate_metadata_index(path, index_path)Reading a row group using the indexed metadata:row_group = 5
metadata = pj.read_row_group_metadata(index_path, row_group)
pr = pq.ParquetReader()
pr.open(path, metadata=metadata)

data = pr.read_row_groups([0])Reading multiple row groups using the indexed metadata:metadata = pj.read_row_groups_metadata(index_path, [5, 7])
pr = pq.ParquetReader()
pr.open(path, metadata=metadata)

data = pr.read_row_groups([0, 1])
Package: pallet-sim
Pallet SimulatorPallet Simulator is a Python package that provides functionalities for visualizing pallets inside orders and simulating
their stability.InstallationYou can install the Pallet Simulator package using pip:pip install pallet-simUsagePlease refer to the examples folder for detailed examples on how to use the Pallet Simulator. The examples demonstrate
how to visualize pallets within orders and simulate their stability.Data StructuresThe Pallet Simulator uses a JSON-based data structure to represent orders. An order object contains the following
fields:{"orderID":"order_id","pallets":[{"palletNr":"palletNr","palletType":"EURO_PALLET","palletDimension":{"x":800.0,"y":1200.0},"boxes":[{"product_code":"0","anchor":{"x":313.0,"y":606.0,"z":0.0},"dimension":{"x":159.0,"y":298.0,"z":211.0},"approach":"9"}]}],"articles":{"0":{"description":"description","weight":5054.0,"shippingGroup":"A"}}}In this structure, an order consists of multiple pallets, each identified by a palletNr. Each pallet has a type
(palletType), dimensions (palletDimension), and a list of boxes (boxes). Each box is defined by a product code
(product_code), anchor coordinates (anchor), dimensions (dimension), and an approach value (approach).The articles field represents the articles or products included in the order. Each article is identified by a numeric
key (e.g., "0") and has a description, weight, and shipping group.The Pallet Simulator utilizes this order structure to generate visual representations of pallets and perform stability
simulations.Feel free to modify and adapt this structure based on your specific requirements and use cases.For more details on how to use the Pallet Simulator, please refer to the documentation and examples provided with the
package.Example files are located under pallet_data/generic_data.LicenseThis project is licensed under the MIT License. See the LICENSE file for details.The MIT License is a permissive open-source license that allows you to use, modify, and distribute the software for both
commercial and non-commercial purposes. It provides you with the freedom to adapt the codebase to suit your needs while
providing attribution to the original authors.For more information about the MIT License, please visit opensource.org/licenses/MIT.
Package: palm
Palm CLI: The extensible CLI at your fingertipsPalmis a universal CLI developed to improve the life and work of data professionals.Palm CLI documentationInstalling Palmpipinstallpalmnote for mac users: if you get this warning:WARNING:Thescriptpalmisinstalledin'/Users/yourname/Library/Python/3.8/bin'whichisnotonPATH.ConsideraddingthisdirectorytoPATHor,ifyouprefertosuppressthiswarning,use--no-warn-script-location.you will need to add'/Users/yourname/Library/Python/3.8/bin'to your path forpalmto work.you can do that with this command:echo"\nexport PATH=$PATH:/Users/yourname/Library/Python/3.8/bin\n">>~/.zprofileUpgrading palmTo upgrade palm to the latest version, usepip install palm -URequirementsYou will needDockerYou can check to see if you already have it withdocker --versionYou will needPython3You can check to see if you already have it withpython3 --versionDeveloping palmIf you have the repo on your computerThis will install whatever version you have checked out at the moment.cdpath/to/this/repo&&python3-mpipuninstallpalm||true# for new installspython3-mpipinstall.You can verify the install withpalm--help
Package: palm2vcal
This package provides a script converting palm OS .dba calendar files into standard .ics vCalendar files.
If requested, the other direction could be easily introduced.It relies mostly on thepalmFile.pyscript written by Aleks Totić, and improved by Jeff Mikels.
In order to generate the vcalendar file, this script uses theicalendarpackage.UsageThe script can simply be called with:palm2vcal <source_file> <dest_file>Where<source_file>and<dest_file>are either file names or-for stdin/stdout.When using the--verboseoption, the number of converted event is printed to stdout (or stderr).EncodingThe target file will be written in UTF8, as perRFC5545.The encoding of the input file defaults to cp1252 (microsoft standard encoding), but another encoding can
be chosen using the--encodingswitch:palm2vcal --encoding=latin1 <source_file> <dest_file>LinksOriginalpalmFile.py:http://www.totic.org/develop/palmFile.pyPalm file format specification:http://www.notsofaqs.com/datebook_dat.phpicalendar documentation:http://readthedocs.org/docs/icalendar/en/latest/vcal format RFC:http://tools.ietf.org/html/rfc5545Package on PyPI:http://pypi.python.org/pypi/palm2vcal/Issues and code onGitHub:http://github.com/rbarrois/palm2vcal
Package: palmari
PalmariA processing pipeline for PALM movies analysis (pre-processing, localization, drift correction, tracking).Check out thedocumentationto get started.Thisnapariplugin was generated withCookiecutterusing@napari'scookiecutter-napari-plugintemplate.InstallationYou can installpalmariviapip:pip install palmariTo install latest development version :pip install git+https://github.com/hippover/palmari.gitContributingContributions are very welcome. Tests can be run withtox, please ensure
the coverage at least stays the same before you submit a pull request.LicenseDistributed under the terms of theCeCILLlicense.IssuesIf you encounter any problems, pleasefile an issuealong with a detailed description.
Package: palmero
# Palmero
Palmero is a hyper-simplification of encryption in Python.## Features### Palmero features encryption key generation based on the identitiy of the machine you’re encrypting on.
Meaning that unless you know the password and are on the machine the file was created on, the file won’t be unlocked. That said, machine ID generation is possible, so you can give someone both the password and your machine’s unique ID to bypass this if need be.### Super easy encryption and decryption
Using Palmero is as easy as calling`encrypt()`or`decrypt`with your source file and password. Palmero has already been tuned to offer high levels of security, and allows for customizablity with some parameters.### Uses Pycryptodome under the hood
Most of the fundementals of the encryption process are handled by Pycryptodome, which allows for many levels of customisability and fine tuning in the source code.
Package: palmerpenguins
palmerpenguinsThe Palmer penguins dataset by Allison Horst, Alison Hill, and Kristen Gorman was first made publicly available as an R package. The goal of the Palmer Penguins dataset is to replace the highly overused Iris dataset for data exploration & visualization.
Using this python package you can easily load the Palmer penguins into your python environment.OverviewSize measurements, clutch observations, and blood isotope ratios for 344 adult foraging Adelie, Chinstrap, and Gentoo penguins observed on islands in the Palmer Archipelago near Palmer Station, Antarctica. Data were collected and made available by Dr. Kristen Gorman and the Palmer Station Long Term Ecological Research (LTER) Program.Examples` from palmerpenguins import load_penguins `` penguins = load_penguins() `LicenseData are available by
[CC-0](https://creativecommons.org/share-your-work/public-domain/cc0/) license in
accordance with the [Palmer Station LTER Data Policy](http://pal.lternet.edu/data/policies)
and the
[LTER Data Access Policy for Type I data](https://lternet.edu/data-access-policy/).BibliographyGorman KB, Williams TD, Fraser WR (2014) Ecological Sexual Dimorphism and Environmental
Variability within a Community of Antarctic Penguins (Genus Pygoscelis). PLoS ONE 9(3):
e90081.https://doi.org/10.1371/journal.pone.0090081See alsoMore information about the dataset is available in
[its official documentation](https://allisonhorst.github.io/palmerpenguins/).The Palmer penguins dataset in Julia:https://github.com/devmotion/PalmerPenguins.jl
Package: palmiche
DocumentationDescriptionThis package is a product of my PhD scripting needs.
It is not meant to be (for now) a proper python package with as
few bugs as possible and reaching compatibility in a lot of ecosystems.
However, I am continually updating it and making more and more clear documentation,
therefore you could find some inspiration on my code to create your own scripts,
(as well as I did on many other codes to createPalmiche).Nevertheless, all your ideas and suggestions are very welcome and for sure I will take them into account to improvePalmiche.What for?Palmicheis a group of scripts that could be used for Molecular Dynamic simulations (launch and analysis), docking and other chemoinformatic operations.
The idea is automate the whole pipeline and improve productivity and transferability.DocumentationThe installation instructions, documentation and tutorials can be found online onReadTheDocs.IssuesIf you have found a bug, please open an issue on theGitHub Issues.DiscussionIf you have questions on how to usePalmiche, or if you want to give feedback or share ideas and new features, please head to theGitHub Discussions.CitingPalmichePlease refer to thecitation pageon the documentation.
Package: palm-vadapter
Palm2 AdapterImplementation of "PaLM2-VAdapter:" from the multi-modal model paper: "PaLM2-VAdapter: Progressively Aligned Language Model Makes a Strong Vision-language Adapter".This model uses a perceiver resampler with a depth of 1 + a tiny palm to efficiently learn the features behind the images and then map them  to the same space as the big model.install$ pip install palm2-vadapterusageimporttorchfrompalm_vadapter.mainimportPaLM2VAdapter# Random text and image tensorstext=torch.randint(0,1000,(1,32),dtype=torch.long)# Image tensorimg=torch.randn(1,3,224,224)# Initialize PaLM2VAdapter modelmodel=PaLM2VAdapter(tiny_dim=512,dim=512,num_tokens=10000,seq_length=32,depth=6,heads=8,image_size=224,patch_size=16,)# Forward pass through the modelout=model(text,img)# Print the shape of the outputprint(out.shape)LicenseMITCitation@misc{xiao2024palm2vadapter,title={PaLM2-VAdapter: Progressively Aligned Language Model Makes a Strong Vision-language Adapter},author={Junfei Xiao and Zheng Xu and Alan Yuille and Shen Yan and Boyu Wang},year={2024},eprint={2402.10896},archivePrefix={arXiv},primaryClass={cs.CV}}