Saravanan666/pypi-org huggingface dataset:
Package: persist_ext
PersistPersistent and Reusable Interactions in Computational NotebooksThis repository contains source code for Persist (PyPi) extension.Persist is a JupyterLab extension to enable persistent interactive outputs in JupyterLab notebooks. Check out the introductory video below.https://github.com/visdesignlab/persist/assets/14944083/c6a9347b-7c93-4d0d-9e60-e10707578327Watch on Youtube with CCPublicationPersist is developed as part of apublicationand is currently under review.AbstractComputational notebooks, such as Jupyter, support rich data visualization. However, even when visualizations in notebooks  are interactive, they still are a dead end: Interactive data manipulations, such as selections, applying labels, filters, categorizations, or fixes to column or cell values, could be efficiently apply in interactive visual components, but interactive components typically cannot manipulate Python data structures. Furthermore, actions performed in interactive plots are volatile, i.e., they are lost as soon as the cell is re-run, prohibiting reusability and reproducibility. To remedy this, we introduce Persist, a family of techniques to capture and apply interaction provenance to enable persistence of interactions. When interactions manipulate data, we make the transformed data available in dataframes that can be accessed in downstream code cells. We implement our approach as a JupyterLab extension that supports tracking interactions in Vega-Altair plots and in a data table view. Persist can re-execute the interaction provenance when a notebook or a cell is re-executed enabling reproducibility and re-use.We evaluated Persist in a user study targeting data manipulations with 11 participants skilled in Python and Pandas, comparing it to traditional code-based approaches. Participants were consistently faster with Persist, were able to correctly complete more tasks, and expressed a strong preference for Persist.Requirements-JupyterLab >= 4.0.0 or Jupyter Notebook >= 7.0.0-pandas >= 0.25-altair >= 5-ipywidgets-anywidgetInstallTo install the extension, execute:pipinstallpersist_extIf the Jupyter server is running, you might have to reload the browser page and restart the kernel.UninstallTo remove the extension, execute:pipuninstallpersist_extContributingDevelopment install
Package: persistiq
API docsInstallationGitpip installgit+git://github.com:tizz98/persistiq.git@masterPyPiComing soonUsageSetupAddPERSIST_IQ_API_KEY='xxxxxxxx'to your environment variablesbash:echo exportPERSIST_IQ_API_KEY='xxxxxxxx'>>~/.bashrczsh:echo exportPERSIST_IQ_API_KEY='xxxxxxxx'>>~/.zshrcwindows: ???Open up a new terminal or:bash:.~/.bashrczsh:.~/.zshrcwindows: ???ResourcesUserfrompersistiqimportUserforuserinUser.list():printuser.id,user.nameLeadfrompersistiqimportLead# NOTE:# Leads will automatically be paginated# to only get the first 100 without pagination set:# >>> Lead.paginate = FalseforleadinLead.list():printlead.id,lead.dataCampaignfrompersistiqimportCampaign# NOTE:# Campaigns will automatically be paginated# to only get the first 100 without pagination set:# >>> Campaign.paginate = FalseforcampaigninCampaign.list():printcampaign.id,campaign.name
Package: persistQueue
This project is based on the achievements of [persist-queue](https://pypi.org/project/persist-queue)persistQueueis a class that created for ease the develop.Requirements` - Python 2.7 - Full support for Linux `Installation` $ pip install persistQueue `Adding path for python shell` $ echo exportPYTHONPATH=.local/lib/python2.7/site-packages/persistQueue:${PYTHONPATH}>> .bashrc `
Package: persisty
Persisty - a better persistence Layer for PythonThe objective of this project is to provide a resource oriented approach
accommodating both security and caching rich enough to handle most use
cases while still being independant of the underlying persistence
mechanism.UsingServeyto provide access via
REST and GraphQL in either a hosted environment or AWS lambda
environemnt, the project includes out of the box support for both
SQL (via SQLAlchemy) and Dynamodb.ConceptsStored ItemsStored items are marked by thestoreddecorator.
This decorator is similar to dataclass, and allows specifying attributes,
keys, schemas, and indexes.StoresAStoreprovides a unified interface for
interacting with stored items.StoreMetacontains
info on what exactly a store supportsStandard Actions are:createan itemreadand item given its keyupdatean itemdeleteand item given its keysearchfor items given filter and sort criteriacountitems given filter criteriaread_batchread a batch of items given a list of keysedit_batchexecute a batch of edits (create, update, delete operations)KeysEach item within a store has a string key, derived from the item. (Possibly based on
one or more of it's attributes) AKeyConfigcontrols this processAttributesStored items haveAttributesassociated with them, similar
to columns in a relational database. Attributes can have generators associated with
them.SearchFiltersSearch operations can haveSearchFiltersThese can be natively supported (Converted to SQL or dynamodb query / scan criteria)
or run locally in python.Auto User InterfacesSince this is built on top of OpenAPI, user interface options supplied byEweyExamplesThe messenger Example Appdemonstrates a step by step build of an
application with security and business logic.Future IdeasREDIS StorageElastic Search StorageRemote HTTP StorageA user app with support for OIDC, SAML and SCIMA Rate Limiting app / Rate Limit Access ControlAn Event Bridge Project (Backed by AWS Event bridge in AWS, or celery in other environments)A Distributed LockAn explicit custom index (Spatial RTree)A Z order indexInstalling local development dependenciespython setup.py install easy_install "persisty[all]"Release ProcedureThe typical process here is:Create a PR with changes. Merge these to main (TheQualityworkflows make sure that your PR
meets the styling, linting, and code coverage standards).New releases created in github are automatically uploaded to pypi
Package: persisty-data
Persisty DataThis is an addition to thepersistyframework for handling binary data
(File Uploads). The objective is to be compatible with third party services, including ones that use signed
URLs for posting / reading (Such as S3).ConceptsDataItemsrepresent the storage of binary data, with methods for reading and writing
as well as obtaining meta such as file size, last modified and etagDataStoresstore data items, with higher level methods for copying efficientlyDataStoreFactorieshandle authorization when creating create data stores,
as well as providing methods for generating presigned urls meaning that the server may be bypassed completely in some
implementations (such as S3)ImplementationsChunkThe chunk implementation breaks up an item intochunkssmaller than preset size and storing
these using regular persisty.DirectoryTheDirectory Storestores data items as files within a directory on a hosted
file system.S3TheS3 Storestores data items as entries in an S3 bucket. It is unique in the stock
implementations in that it also provides anS3 Data Store Factoryrather
than relying on theHosted Data Store Factoryused by other
implementations for providing pre-signed read urls andUpload Forms.Reading DataWriting dataStrategy for bypassing server using Signed URLsExampleExampleA variant of the persisty messenger example application demonstrates file upload.Installing local development dependenciespython setup.py install easy_install "persisty-data[dev]"Release ProcedureThe typical process here is:Create a PR with changes. Merge these to main (TheQualityworkflows make sure that your PR
meets the styling, linting, and code coverage standards).New releases created in github are automatically uploaded to pypi
Package: persona-idp
This is a generic and reusable python implementation ofMozilla Persona Identity Provider.This module is used on our production servers and authenticates users
against our internal Active Directory controller.See alsoBrowserID specificationfor more details.InstallationEither:$ git clone https://github.com/dpaw2/persona-idp
$ cd persona-idp
$ python setup.py installor:$ pip install persona-idpUsagePlease,modifyat least the secret and rsa_key (unless you want to haveserious securityissues):$ cat wsgi.py
from persona_idp.idp import PersonaIDP

application = PersonaIDP(rsa_key='/etc/apache2/certs/private.pem',
                         secret='my123secret',
                         provision_template='/tmp/provision.txt')and:$ gunicorn --workers=2 wsgi:applicationor:$ echo 'WSGIScriptAlias /persona /var/www/persona/wsgi.py' >> \
>   /etc/apache2/conf.d/persona.confExamplesSee theexamples/folder.Tests$ python setup.py testHelpJoin thedpawmailing list, or read the archives, athttp://groups.google.com/group/dpawIssuesUse our github issue tracker, athttps://github.com/dpaw2/persona-idp/issuesContribute$ git clone https://github.com/dpaw2/persona-idp
$ python setup.py developWe prefer patches submitted via pull requests, athttps://github.com/dpaw2/persona-idp/pullsAcknowledgementsThis work is based on previous work of @djc and hispersona-totp.
Package: personal-cli-assistant
Comand Line Interface assistantWhat is this?The CLI assistant allows you to:
Create and work with Contacts lists.
Create and work with the notes.
Sorting files in the folders.
You can choose your options in the console.Install GuideTo install this package open the terminal in your code editor and type:pip install personal-cli-assistantUsingUsing the CLI assistant provides by next steps:Open the terminal;Type: start_cli;Command Line interface give you all hints to make different actions.DeveloperOur url:link
Package: personalcolorchecker
personalcolorcheckerBy giving your photo as data, it will tell you your personal color based on your eye color and skin color.how to install personalcolorchecker$ pip install personalcolorcheckerhow to personalcolorDownload "haarcascade_frontalface_default.xml"$ import personalcolorchecker$ import cv2$ img = cv2.imread("image.jpg")$ personalcolorchecker.personal_color(img)
Package: personal-interfaces
Personal InterfaceThe Personal Interface is a Python project that provides a simple model for connecting to a database using the Deta library, among other utilities as loggers. It offers basic database operations such as querying, creating, updating, and deleting records. This README provides an overview of the project, installation instructions, and usage examples.Table of ContentsPersonal InterfaceTable of ContentsInstallationUsageDetaDatabaseContributingLicenseInstallationBefore you can use the Personal Interface, make sure you have Python installed on your system. You'll also need to set up a Deta project and obtain an API key. Follow these steps to get started:Clone the repository:pipinstallpersonal_interfacesSet your Deta project API key as an environment variable:Method 1Using bash:exportDB_ACCESS_TOKEN=your_api_keyMethod 2Using a.envDB_ACCESS_TOKEN = your_api_keyReplaceyour_api_keywith your actual Deta API key.Set your private API key to access and use the code:Method 1Using bash:exportAPI_KEY=your_api_keyMethod 2Using a.envAPI_KEY = your_api_keyReplaceyour_api_keywith your actual Deta API key.UsageThis interface can only be used with a privateAPI_KEY. Without it, the tool is not functional.DetaDatabaseThe Personal Interface provides a simple way to interact with your Deta database. Here's how you can use it in your Python code:Import theDetaDatabaseclass:frompersonal_interfacesimportDetaDatabaseCreate an instance of theDetaDatabaseclass and connect to your Deta database:db=DetaDatabase()db.connect("your_database_name")Replace"your_database_name"with the name of your Deta database.Perform database operations such as querying, creating, updating, and deleting records using the provided methods. For example:# Query for recordsdata={"name":"John"}results=db.query(data,filter_by="equal")# Create a new recordnew_data={"name":"Alice","age":30}key=db.create(new_data)# Update an existing recordupdated_data={"key":key,"age":31}db.update(updated_data)# Delete a record by its keydb.delete(key)For more details on how to use the Personal Interface, refer to thePython code documentationin the repository.ContributingContributions to this project are welcome! If you have suggestions, feature requests, or would like to report a bug, please open an issue on theGitHub repository. If you'd like to contribute code, please fork the repository, make your changes, and submit a pull request.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: personality_questionnaire
personality_questionnairePersonality questionnaire processing methods for various experiments.Supported QuestionnairesBFI-2InputsQuestionnaire answers are...ints in a numpy ndarray (.npy)ints in a csv file (.csv)strings in a csv file (.csv)OutputsThe following values are scaled to the range [0..1] per participant:Big Five (OCEAN)FACETSetupInstall package from PyPIpip install personality_questionnaireInstall package for developmentgit clone https://github.com/fodorad/personality_questionnaire
cd personality_questionnaire
pip install .
pip install -U -r requirements.txt
python -m unittest discover -s testProjects using exordium(2022) PersonalityLinMulTLinMulT is trained for Big Five personality trait estimation using the First Impressions V2 dataset and sentiment estimation using the MOSI and MOSEI datasets.paper: Multimodal Sentiment and Personality Perception Under Speech: A Comparison of Transformer-based Architectures (pdf,website)code:https://github.com/fodorad/PersonalityLinMulTWhat's nextAdd support for the following questionnaires: HEXACO, VAS-FContactÁdám Fodor (foauaai@inf.elte.hu)
Package: personalization
personalizationAn end-to-end demo machine learning pipeline to provide an artifact for a real-time inference serviceAimWe want to create a machine learning training code which satisfies the following properties that given
data can train the model and save it to artifactSolutionOur implementation of the package 'personalization'
We choose to use Polars to read data, it is roughly 2-3 times faster than Pandas and supports nice API for
aggregations and features creation.
For the model part, we decided to take lightGBM  due to ts speed, small size (model artifact size up to 50 Mb on 300 million rows of search data) and explainability. The user should choose lightGBM parameters carefully.
We tested an example lightgbm params in notebooks/train.ipynb.Offline evaluationThe offline evaluation has been done in notebooks/train.ipynb, we can see significant increase in NDCG levels across venues with our model against the baseline.CICD: code style and PyPIThe code is checked with pre-commit configs, tested and published in Github Actions, current coverage is around 80 percent.The inference service code can be found herehttps://github.com/ra312/model-serverHow to runObtain sessions.csv and venues.csv and move them to the root folderInstall personalizationpython -m pip instal personalizationRun the following command in shell to train pipeline and get artifact:python3 -m personalization \--sessions-bucket-path sessions.csv \--venues-bucket-path venues.csv \--objective lambdarank \--num_leaves 100 \--min_sum_hessian_in_leaf 10 \--metric ndcg --ndcg_eval_at 10 20 \--learning_rate 0.8 \--force_row_wise True \--num_iterations 10 \--trained-model-path trained_model.joblibTODONext steps:Scalability(e.g. use Flyte)Data: add support to ingest sessions and venues data from a databaseVersioning: add MLFlow integrationDevelopmentClone this repositoryRequirements:PoetryPython 3.8.1+Create a virtual environment and install the dependenciespoetryinstallActivate the virtual environmentpoetryshellTestingpytestPre-commitPre-commit hooks run all the auto-formatters (e.g.black,isort), linters (e.g.mypy,flake8), and other quality
checks to make sure the changeset is in good shape before a commit/push happens.You can install the hooks with (runs for each commit):pre-commitinstallOr if you want them to run only for each push:pre-commitinstall-tpre-pushOr if you want e.g. want to run all checks manually for all files:pre-commitrun--all-filesThis project was generated using thewolt-python-package-cookiecuttertemplate.
Package: personalize-sam
Personalize Segment Anything with 1 Shot in 10 SecondsOfficial implementation of'Personalize Segment Anything Model with One Shot'.NewsTODO: Release the PerSAM-assistedDreamboothfor better fine-tuningStable Diffusion📌.We release the code of PerSAM and PerSAM-F 🔥. Check ourdemohere!We release a new dataset for personalized segmentation,PerSeg🔥.IntroductionHow to customize SAM to automatically segment your pet dog in a photo album?In this project, we propose a training-freePersonalization approach forSegment Anything Model (SAM), termed asPerSAM. Given only a single image with a reference mask, PerSAM can segment specific visual concepts, e.g., your pet dog, within other images or videos without any training.
For better performance, we further present an efficient one-shot fine-tuning variant,PerSAM-F. We freeze the entire SAM and introduce two learnable mask weights, which only trains2 parameterswithin10 seconds.Besides, our approach can be utilized to assistDreamBoothin fine-tuning betterStable Diffusionfor personalized image synthesis. We adopt PerSAM to segment the target object in the user-provided few-shot images, which eliminates thebackground disturbanceand benefits the target representation learning.RequirementsInstallationClone the repo and create a conda environment:gitclonehttps://github.com/ZrrSkywalker/Personalize-SAM.gitcdPersonalize-SAM

condacreate-npersampython=3.8
condaactivatepersam

pipinstall-rrequirements.txtSimilar to Segment Anything, our code requirespytorch>=1.7andtorchvision>=0.8. Please follow the instructionshereto install both PyTorch and TorchVision dependencies.PreparationPlease download our constructed datasetPerSegfor personalized segmentation fromGoogle DriveorBaidu Yun(code222k), and the pre-trained weights of SAM fromhere. Then, unzip the dataset file and organize them asdata/
|–– Annotations/
|–– Images/
sam_vit_h_4b8939.pthGetting StartedPersonalized SegmentationFor the training-free 🧊PerSAM, just run:pythonpersam.py--outdir<outputfilename>For 10-second fine-tuning of 🚀PerSAM-F, just run:pythonpersam_f.py--outdir<outputfilename>After running, the output masks and visualzations will be stored atoutputs/<output filename>.Then, for mIoU evaluation, please run:pythoneval_miou.py--pred_path<outputfilename>Personalized Stable DiffusionOur approach can enhance DreamBooth to better personalize Stable Diffusion for text-to-image generation.Comming soon.Citation@misc{zhang2023personalize,title={PersonalizeSegmentAnythingModelwithOneShot},author={RenruiZhangandZhengkaiJiangandZiyuGuoandShilinYanandJuntingPanandHaoDongandPengGaoandHongshengLi},year={2023},eprint={2305.03048},archivePrefix={arXiv},primaryClass={cs.CV}}AcknowledgementThis repo benefits fromSegment AnythingandDreamBooth. Thanks for their wonderful works.ContactIf you have any question about this project, please feel free to contactzhangrenrui@pjlab.org.cn.
Package: personal-man
personal-man (pman)NoteI am archiving this project in favor ofcheat, which provides the same features and more!Personal ManpagesInstallationInstallripgrepInstall thepmanCLI with pipxpipxinstallpersonal-manRunpmanto check that installation succeeded and to see the available commandsThe help output will display the directory for your personal manpages, but you can change the default by exporting an environment variable:PMAN_DOC_PATH. I personally have a directory within my main Obsidian vault so that I can edit the files inObsidianand search withpmanUsageFor more example code, see thescriptsdirectory or thetests.Project StatusSee theOpen Issuesand/or theCODE_TAG_SUMMARY. For release history, see theCHANGELOG.ContributingWe welcome pull requests! For your pull request to be accepted smoothly, we suggest that you first open a GitHub issue to discuss your idea. For resources on getting started with the code base, see the below documentation:DEVELOPER_GUIDESTYLE_GUIDECode of ConductWe follow theContributor Covenant Code of Conduct.Open Source StatusWe try to reasonably meet most aspects of the "OpenSSF scorecard" fromOpen Source InsightsResponsible DisclosureIf you have any security issue to report, please contact the project maintainers privately. You can reach us atdev.act.kyle@gmail.com.LicenseLICENSE
Package: personal-page-creator
Personal Page CreatorPython script to create customizable website intended for GitHub pages.Inspired byGit FolioInstallingTo install the package, run -pipinstallpersonal-page-creatorOr view it atPyPIUsageInitializeUse init to initialize the config fileppcinitInit will create a config file which is used to customize the page.BuildppcbuildBuild will use the config file to generate the required HTML and CSS files.ServeWant to check the output before hosting? Use 'serve' to start a local http server.ppcserveCustomizationsConfig KeysInputFunctionsexcludedSpecify a list of repo namesThe specified repos will not be included as part of the siteside_backgroundURLImage from the url will be used as side background of the sitesocialDict will key and valueUsed to give links to the user's profile,Currenty supports linkedin, bitbucket and twittercv_pathURL or filenameUsed to give download link to the user's cv ( Curriculum Vitae )ExampleBelow is an example config file which uses are the available functions.{"username":"your-github-username","excluded":["this-repo-will-be-excluded"],"social":{"linkedin":"linkedin_username","twitter":"twitter_handle","bitbucket":"bitbucket_username"},"side_background":"http://www.example.com/path/to/image.jpg","cv_path":"path/to/cv.pdf"}TODOConfig to add organization repo alsoAdd themes
Package: persona-test-user
A base test class that can be extended by other tests to include utility methods.
API docs:https://github.com/mozilla/personatestuser.org#apiUsage:
verified = bool:
Verified refers to the user’s account and password already approved and set upenv = str:
Strings “dev”, “stage” or “prod” will return users for the respective environments
If “None” a production Persona user will be returned.env = dict:
For custom browserid databases and verifiers
self.user = PersonaTestUser().create_user(verified=True,
env={“browserid”:”firefoxos.persona.org”, “verifier”:”firefoxos.123done.org”})
Package: person-cache
Person CacheCache para aplicacoes python com Redis ou em Memoria Local.Exemplo de Utilizacaofromperson_cache.mainimportRedisSingletonascachefromperson_cache.mainimportLocalCachecache(url_redis="redis://default:redis1234@localhost:6379/0")LocalCache()@cache.cache_response(key_prefix="teste",expire_time=600,skip_args=0)asyncdefteste(abc):return1+abc@LocalCache.cache_response(key_prefix="teste1",expire_time=600,skip_args=0)asyncdefteste1(abc):return5*abcComo UsarPara cache com redis, necessário incluir aurl_redispara instanciar a classe. Já para o cache local não é necessário.Ao utilizar o decorator, em ambos os casos, é necessário informar:key_prefix: Prefixo que será utilizado para compor a chave do chave;expire_time: tempo em segundos para expirar o cache;skip_args: a quantidade de args que deve ser desprezada para compor a chave do cache. Isso se faz necessários em caso que é informado por referencia a dependecia de banco de dados, por exemplo;O person cache foi idealizado considerando aplicacoes assincronas.
Package: person-counter
Person counterfrom opencv_stream import VideoStreamer, FpsDrawer
from person_counter.model import PersonCounterModel, PersonCounterOutput
import numpy as np
import osVIDEO_DIR = "D:/project/facebodydetection/facebodydetect/app/src/videos"
def get_video():
paths = [ os.path.join(VIDEO_DIR, p) for p in os.listdir(VIDEO_DIR)]
return np.random.choice(paths)stream = VideoStreamer.from_video_input(get_video())
fps = FpsDrawer()model = PersonCounterModel()@stream.on_next_frame()
def index(frame: np.ndarray):result = model.predict(frame)if result.is_ok():
output: PersonCounterOutput = result.unwrap()
output.draw(frame)
else:
raise result.exceptionfps.draw(frame)stream.start()