Saravanan666/pypi-org huggingface dataset:
Package: protypo
Protypo: A Python Library for Language ModelsA Python Library for Language ModelsDocumentation:https://protypo.entelecheia.aiGitHub:https://github.com/entelecheia/protypoPyPI:https://pypi.org/project/protypoProtypo is a versatile and powerful Python library designed to facilitate the creation, training, and deployment of cutting-edge language models, a fundamental component in natural language processing (NLP) and artificial intelligence (AI) applications. The name Protypo is derived from the Greek word πρότυπο, meaning "prototype" or "model," reflecting the library's focus on providing a solid foundation for language model development.FeaturesProtypo offers a wide range of features that cater to both newcomers and experienced professionals in the NLP field:Intuitive API: Protypo provides an easy-to-use and user-friendly API, enabling developers to create, train, and fine-tune language models with minimal lines of code.Flexible architecture: The library supports various state-of-the-art language model architectures, such as Transformer, LSTM, and GRU, allowing users to experiment with different approaches and find the best fit for their projects.Pre-trained models: Protypo comes with a collection of pre-trained models for various languages, domains, and tasks, enabling users to leverage transfer learning and quickly adapt these models to their specific requirements.Customizability: Users can build custom language models from scratch or fine-tune existing ones, providing full control over model architecture, training parameters, and optimization techniques.Multilingual support: Protypo is designed with a focus on multilingualism, supporting a wide range of languages and facilitating seamless integration with other language resources and tools.InstallationYou can install Protypo using pip:pipinstallprotypoGetting StartedTo get started with Protypo, check out theofficial documentationand theGitHub repositoryfor examples, tutorials, and more information.ChangelogSee theCHANGELOGfor more information.ContributingContributions are welcome! Please see thecontributing guidelinesfor more information.LicenseThis project is released under theMIT License.
Package: proudcat
File        : README.md
Maintainer  : Felix C. Stegerman <flx@obfusk.net>
Date        : 2020-07-02

Copyright   : Copyright (C) 2020  Felix C. Stegerman
Version     : v0.2.0
License     : GPLv3+Descriptionproudcat - cat + :rainbow:proudcat is basically a variant ofproudcat-rust/pridecatwritten in python.Help$proudcat--helpRequirementsPython >= 3.5 + click.InstallingUsing pip$pipinstallproudcatManuallyInstall the dependencies (as e.g. debian packages or usingpip):$aptinstallpython3-click# debian/ubuntu$pipinstallclick# pipThen just putproudcatsomewhere on your$PATH(e.g.~/bin).License
Package: proust
ProustOnline time series analysisSetting up a development environment[Insert typical language about using some python environment]. Within that
environment, run the following:# Install editable version of codepipinstall-e.# Install testing dependenciespipinstall-e.[testing]# Install pre-commit hookspre-commitinstallContributingWe use thepre-committools to automatically lint (and fix, where possible)
for Python warnings, errors, and style. This runs automatically ongit commitand will either pass with no issue, make changes to files, and / or ask you to
make fixes. If the tests don't pass, the commit fails (a good thing! Keeps
history clean).TestingWe also usepytest, which we encourage you to run before contributing (pytest -n autofor parallelized testing).DocumentationTo update the doc coverage badge, rundocstring-coverage-b.github/badges/docstring_coverage.svg.VersioningTo update the version, runbumpversion[major|minor|patch]
Package: prov
A library for W3C Provenance Data Model supporting PROV-O (RDF), PROV-XML, PROV-JSON import/exportFree software: MIT licenseDocumentation:http://prov.readthedocs.io/.Python 3 only.FeaturesAn implementation of theW3C PROV Data Modelin Python.In-memory classes for PROV assertions, which can then be output asPROV-NSerialization and deserialization support:PROV-O(RDF),PROV-XMLandPROV-JSON.Exporting PROV documents into various graphical formats (e.g. PDF, PNG, SVG).Convert a PROV document to aNetworkx MultiDiGraphand back.UsesSeea short tutorialfor using this package.This package is used extensively byProvStore,
a free online repository for provenance documents.
Package: prov2neo
Welcome toprov2neo! 👋prov2neois a Python library and command line tool that imports W3C PROV documents intoNeo4j.prov2neoenables faster imports than comparable libs such asprov-db-connectorwith the limitation of being specialized for neo4j.🏗️ InstallationClone the project and use the providedsetup.pyto installprov2neolocally:pythonsetup.pyinstall--userOr install the latest release fromPyPi:pipinstallprov2neo🚀 Usageprov2neo can be used as a command line script or as a Python lib.As a Command Line Scriptusage: prov2neo [-h] [-f {provn,json,rdf,xml}] [-i INPUT [INPUT ...]] [-a ADDRESS]
                [-u USERNAME] [-p PASSWORD] [-n NAME]
                [-s {bolt,bolt+s,bolt+ssc,http,https,http+s,http+ssc}]

Import W3C PROV documents to Neo4j.

optional arguments:
  -h, --help            show this help message and exit
  -f {provn,json,rdf,xml}, --format {provn,json,rdf,xml}
                        input PROV format
  -i INPUT [INPUT ...], --input INPUT [INPUT ...]
                        input files, use '.' for stdin
  -a ADDRESS, --address ADDRESS
                        Neo4j address
  -u USERNAME, --username USERNAME
                        Neo4j username
  -p PASSWORD, --password PASSWORD
                        Neo4j password
  -n NAME, --name NAME  Neo4j target database name
  -s {bolt,bolt+s,bolt+ssc,http,https,http+s,http+ssc}, --scheme {bolt,bolt+s,bolt+ssc,http,https,http+s,http+ssc}
                        connection scheme to use when connecting to Neo4jAs a Python Libfromprov.modelimportProvDocumentfromprov2neo.clientimportClient# read graph from JSON serializationgraph=ProvDocument.deserialize(source="examples/horsemeat.json",format="json")# create a prov2neo clientclient=Client()# connect to the neo4j instanceclient.connect(address="localhost:7687",user="jane doe",password="**redacted**",name="database name",scheme="bolt")# import the PROV graphclient.import_graph(graph)prov2neo supports formats that theprovlibrary provides:PROV-NPROV-O(RDF)PROV-XMLPROV-JSON🤝 ContributingContributions and pull requests are welcome!For major changes, please open an issue first to discuss what you would like to change.✨ Citable SoftwareThis project contains aCITATION.cfffile!CITATION.cfffiles are plain text files with human- and machine-readable citation information for software (and datasets).GitHub will link the correct citation automatically.To find out more about GitHubs support forCITATION.cfffiles visithere📝 LicenseCopyright © 2020-2022German Aerospace Center (DLR)and individual contributors.This project isMITlicensed.
Package: provablyfair
Provably fairref:https://dicesites.com/provably-fairExamplefromprovablyfairimportProvablyFairf=ProvablyFair("293d5d2ddd365f54759283a8097ab2640cbe6f8864adc2b1b31e65c14c999f04")r=f.roll("ClientSeedForDiceSites.com")print(r.roll%(10000)/100)
Package: prove-assignment
AlDa PipelineSetting up a CI/CD pipeline to automate development process using the Gitlab CI/CD infrastructure. 1st Assignment for Processo e sviluppo del software course @unimibWhat's has been done so farWe created.gtilab-ci.ymlfile where are definded all the stages and jobs listed in the Assignment file.The project is a simple Python program usingyfinanceandpandasas a requirement. It downloads, using Yahoo Finance APIs, the latest stock prices and volume order of Apple stock. A function able to compute returns (based on adj closes) will be added later.Regarding the stages developed this is the current status:StageStatusBuild:heavy_check_mark: This stage is currently working fineVerify:heavy_check_mark: This stage is currently performing static and dynamic analysis correctly usingProspectorandBanditUnit test:heavy_check_mark: This stage is currently working fineIntegration testThis stage is currently under developmentPackage:heavy_check_mark: Stage is working and creating pkgs in./dist/folderRelaseThis stage is currently under developmentDeployThis stage is currently under development
Package: proved
======
PROVED (PRocess mining OVer uncErtain Data)Branch dedicated to the experiments for the paper"Efficient Construction of Behavior Graphs for Uncertain Event Data",
Marco Pegoraro, Merih Seran Uysal, Wil M.P. van der Aalst,
InInternational Conference on Business Information Systems (BIS), 2020.Experiments are in the folder experiments. Needs additional data files to run:BPI_Challenge_2012.xes: fromhttps://data.4tu.nl/repository/uuid:3926db30-f712-4394-aebc-75976070e91fHelp_Desk_event_log.xes: fromhttps://data.4tu.nl/repository/uuid:0c60edf1-6f83-4e75-9367-4c63b3e9d5bbRoad_Traffic_Fine_Management_Process.xes: fromhttps://data.4tu.nl/repository/uuid:270fd440-1057-4fb9-89a9-b699b47990f5For more information seehttp://mpegoraro.net/pages/research.htmlFree software: GNU General Public License v3Documentation: Coming soon!FeaturesComing soon!CreditsThis package was created with Cookiecutter_ and theaudreyr/cookiecutter-pypackage_ project template... _Cookiecutter:https://github.com/audreyr/cookiecutter.. _audreyr/cookiecutter-pypackage:https://github.com/audreyr/cookiecutter-pypackage=======
History0.1.0 (2019-08-22)First release on PyPI.
Package: provenance
provenanceis a Python library for function-level caching and provenance that aids in
creating Parsimonious Pythonic Pipelines™. By wrapping functions in theprovenancedecorator computed results are cached across various tiered stores (disk, S3, SFTP) andprovenance(i.e. lineage) information is tracked
and stored in an artifact repository. A central artifact repository can be used to enable
production pipelines, team collaboration, and reproducible results. The library is general
purpose but was built with machine learning pipelines in mind. By leveraging the fantasticjobliblibrary object serialization is optimized fornumpyand other PyData libraries.What that means in practice is that you can easily keep track of how artifacts (models,
features, or any object or file) are created, where they are used, and have a central place
to store and share these artifacts. This basic plumbing is required (or at least desired!)
in any machine learning pipeline and project.provenancecan be used standalone along with
a build server to run pipelines or in conjunction with more advanced workflow systems
(e.g.Airflow,Luigi).ExampleFor an explanation of this example please see theIntroductory Guide.importprovenanceaspp.load_config(...)importtime@p.provenance()defexpensive_add(a,b):time.sleep(2)returna+b@p.provenance()defexpensive_mult(a,b):time.sleep(2)returna*ba1=expensive_add(4,3)a2=expensive_add(1,1)result=expensive_mult(a1,a2)vis.visualize_lineage(result)InstallationFor the base functionality:pipinstallprovenanceFor the visualization module (which requiresgraphvizto be installed):pipinstallprovenance[vis]For the SFTP store:pipinstallprovenance[sftp]For everything all at once:pipinstallprovenance[all]provenance is also available from conda-forge for conda installations:condainstall-cconda-forgeprovenanceCompatibilityprovenanceis currently only compatible with Python 3.5 and higher. Updating it to work with Python 2.7x
should be easy, follow thisticketif you are interested in that.
Package: prove-test-runner
Real Python Feed ReaderThe Real Python Feed Reader is a basicweb feedreader that can download the latest Real Python tutorials from theReal Python feed.For more information see the tutorialHow to Publish an Open-Source Python Package to PyPIon Real Python.InstallationYou can install the Real Python Feed Reader fromPyPI:python -m pip install realpython-readerThe reader is supported on Python 3.7 and above. Older versions of Python, including Python 2.7, are supported by version 1.0.0 of the reader.How to useThe Real Python Feed Reader is a command line application, namedrealpython. To see a list of thelatest Real Python tutorials, call the program without any arguments:$ realpython
The latest tutorials from Real Python (https://realpython.com/)
 0 How to Publish an Open-Source Python Package to PyPI
 1 Python "while" Loops (Indefinite Iteration)
 2 Writing Comments in Python (Guide)
 3 Setting Up Python for Machine Learning on Windows
 4 Python Community Interview With Michael Kennedy
 5 Practical Text Classification With Python and Keras
 6 Getting Started With Testing in Python
 7 Python, Boto3, and AWS S3: Demystified
 8 Python's range() Function (Guide)
 9 Python Community Interview With Mike Grouchy
10 How to Round Numbers in Python
11 Building and Documenting Python REST APIs With Flask and Connexion â€“ Part 2
12 Splitting, Concatenating, and Joining Strings in Python
13 Image Segmentation Using Color Spaces in OpenCV + Python
14 Python Community Interview With Mahdi Yusuf
15 Absolute vs Relative Imports in Python
16 Top 10 Must-Watch PyCon Talks
17 Logging in Python
18 The Best Python Books
19 Conditional Statements in PythonTo read one particular tutorial, call the program with the numerical ID of the tutorial as a parameter:$ realpython 0
# How to Publish an Open-Source Python Package to PyPI

Python is famous for coming with batteries included. Sophisticated
capabilities are available in the standard library. You can find modules for
working with sockets, parsing CSV, JSON, and XML files, and working with
files and file paths.

However great the packages included with Python are, there are many
fantastic projects available outside the standard library. These are most
often hosted at the Python Packaging Index (PyPI), historically known as the
Cheese Shop. At PyPI, you can find everything from Hello World to advanced
deep learning libraries.

[... The full text of the article ...]You can also call the Real Python Feed Reader in your own Python code, by importing from thereaderpackage:>>> from reader import feed
>>> feed.get_titles()
['How to Publish an Open-Source Python Package to PyPI', ...]
Package: providah
providahprovidah is a small, simple utility. It is an opinionated approach to creating object factories in Python without adding
the additional complexity of maintaining factories.ConceptThe library is utilized as a basic global (to package) Iversion of Control (IoC) Container (Dependency Injection Container). The idea
as presented is to provide an approach where all class in a package will automatically be registered. You can also override a specific
registered class when you have monkey patched the class. When a new class is added it can manually be added to the registry, and this
is helpful for application level classes, local extensions to a library, and so on. In even other situations you may want to add a
a class when you want to retain the default version of a class, but want to support an alternative version as well.DesignExamplesExample 1 - Library FactoryWithin an __init__ .py - often at the root of a library's source code. This is ideal when you want to register all classes in
the library in a single factory.fromprovidah.factories.package_factoryimportPackageFactoryPackageFactory.fill_registry()Example 2 - PatchingWhen You want to monkey patch the functionality of a class.fromXimportYfromprovidah.factories.package_factoryimportPackageFactorydefnew_method(params):print('Hello there')Y.print=new_method()PackageFactory.register(key=str('Y'),library=str('X'),class_def=Y)Example 3 - Ad Hoc RegistrationWhen you want to add a class that will later be referenced by a label - in the case you are creating more than one class with the
same key, but not using library identifiers.classWriter:@classmethoddefwrite(cls)->None:raiseNotImplementedError('Base class method - must be implemented.')classA(Writer):@classmethoddefwrite(cls)->None:print("Hello World")importsqlite3classB(Writer):__db_conn:sqlite3.connect('B.db')@classmethoddefwrite(cls):cls.__write_to_db('Hello World')@classmethoddef__write_to_db(cls,data:str)->None:withcls.db_conn.cursor()ascursor:cursor.execute(f"INSERT INTO logs VALUES ({data})")cursor.commit()fromprovidah.factories.package_factoryimportPackageFactoryPackageFactory.register(key=str('A'),class_def=A,label=str('print_writer'))PackageFactory.register(key=str('B'),class_def=A,label=str('db_writer'))Example 4 - Using IoC Factoryfromprovidah.factories.package_factoryimportPackageFactory# Must import library - when library classes added to factory as in Example 1 (above) the# runtime execution of this will happen when the library is imported.importsome_packageimportanother_package# To make sure we get the right version - Exceptions occur otherwise.some_obj=PackageFactory.create('bob',library='some_package')another_obj=PackageFactory.create('bob',library='another_package')
Package: provide-dir
provide_directoryFunction to create the given path, including potential parent directories. Writes to the provided sink (e.g.print) whether the directory was created or whether it already existed.DependenciesNoneUsagefrompathlibimportPathfromprovide_dirimportprovide_dirneeded_path=Path("/path/to/directory/with/subdirectories")provide_dir(needed_path,print)InstallationPippip install provide_dirDeveloper's InstallationYou can clone the repository and install it withpip install -e /path/to/local/repository.Test dependenciesTo run the tests you will needpytestremove_directoryre_patterns
Package: provider
Provider Development KitCommon Fate Provider Development Kit for Python.What is a provider?A Provider is a Python service which provides a consistent API for managing fine-grain permissions.Managing permissions in cloud providers, SaaS applications, and CI/CD platforms usually requires access to highly sensitive secrets, like administrative API tokens. The Provider framework allows for access to be granted and revoked to these platforms without requiring direct access to these tokens:What does the Provider Development Kit do?The Provider Development Kit (PDK) makes it easy to develop and deploy Providers.classProvider(provider.Provider):api_url=provider.String()@access.target()classTarget:...@access.grant()defgrant(p:Provider,subject:str,target:Target):# perform API calls here to grant access...@access.revoke()defrevoke(p:Provider,subject:str,target:Target):# perform API calls here to revoke access...The PDK handles configuration and packaging into a cloud-native function which can be executed by an application.Supported runtimesCurrently the supported runtimes for Providers are as follows:AWS LambdaProvider SchemasEach Provider has a strongly-typed schema. An example schema is shown below:{"audit":{"resourceLoaders":{},"resources":{}},"config":{},"target":{"MyTarget":{"schema":{"first":{"description":"first var","id":"first","resourceName":null,"title":"First","type":"string"}}}}}The schema is based onJSON Schemaand allows applications using Providers to interpret the available resources and display the appropriate UI.
Package: provisio
ProvisioSmall utility library containing city provision metric used in other projectsBase usage exampleUsedongraphioto get city's IntermodalGraph and adjacency matrix between two geodataframespip install provisioimportpandasaspdimportgeopandasasgpdimportnetworkxasnxfromprovisioimport*builds=gpd.read_file("test_data/buildings.geojson")services=gpd.read_file("test_data/services.geojson")matrix=pd.read_csv("test_data/matrix.csv")demanded_building=demands_from_buildings_by_normative(builds,0.1)prvs_buildings,prvs_services,prvs_links=get_service_provision(services=services,demanded_buildings=demanded_buildings,adjacency_matrix=matrix,threshold=10).get_provisions()
Package: provision-py-proj
provision_py_projProvision an empty Python package.Create empty Package with following structure:test_pkg
├── bin
│   └── test_pkg
├── .gitignore
├── LICENSE.txt
├── MANIFEST.in
├── README.md
├── requirements.txt
├── setup.py
└── test_pkg
    ├── __init__.py
    └── test
        └── __init__.pyInstallationpip3 install provision_py_projUsageprovision_py_proj --help
Package: provit
provitis a data provenance annotation and documentation tool. It provides various feature for
creation and retrieval of provenance information for data stored in files. The tracking of sources,
modifications and merges allows the user to keep a log of all modifications a dataset was subject
to. This is especially useful for dataset which are accessed intermittently or part of a long
running workflow (e.g. for a scientific thesis). Furthermore, provenance data stored next to the
data in an archive can help others to identify quality, value and acutality of the data.provitdoes not require any external infrastructure. All information is stored in.provfiles right next to the data files as a JSON-LD graph. This makes it the perfect tool for small
teams or individual researchers.To allow interoperatibility, a small subset of theW3CPROV-O
vocabularyis implemented. Therefore, the provenance
information can easily be merge in a linked data graph if necessary, at a later stage of the project.provitaims to provided an easy to use interface for users who have never worked with provenance
tracking before. You can operate the tool using theIf you feel limited by PROVIT you should have a look at
more extensive implementations, e.g.:prov.Full documentation is available under:provit.readthedocs.io.Quick InstallationNoteprovitrequires a working installation of Python 3.7, furthermore the use of avirtualenvis strongly encouraged.
If you need help to set this up, please follow the Installation section in the documentation.provitis availabe via the Python Package Index (PyPI) and can be installed by using
pippip. Simply create a virtualenvironment with your
preferred method a run thepip installcommand:$mkvirtualenvprovit$pipinstallprovitQuickstartprovitprovides three modes of interaction:command line interfacegraphical user interfacepython packageAll of them allow you to track provenance, but theprovit browseradditionally lets you explore tracked provenance.provit browserYou can start provit browser directly from your terminal:$provitbrowserprovit cliSimplycdto the directory, where your data is located, create (or append to an already existing) provenance file.$provitaddFILEPATH[OPTIONS]The –help command shows you the full list of available options and arguments.$provit--helpprovit packageUsing provit in your ETL pipeline is easy. simply import the Proveance class
and start using it (e.g. as displayed below).fromprovitimportProvenance# load prov data for a file, or create new prov for fileprov=Provenance(<filepath>)# add provenance metadataprov.add(agents=["agent"],activity="activity",description="...")prov.add_primary_source("primary_source")prov.add_sources(["filepath1","filepath2"])# return provenance as json treeprov_dict=prov.tree()# save provenance metadata into "<filename>.prov" fileprov.save()RoadmapWe have a small roadmap, which we will make transparent below:Increase test coverage (currently 81%)Windows support (all devs are on Linux)Agent management in PROVIT BrowserOverviewAuthors:P. Mühledermuehleder@ub.uni-leipzig.de,
F. Rämischraemisch@ub.uni-leipzig.deLicense:MITCopyright:2018-2019, Peter Mühleder andUniversitätsbibliothek Leipzig