Saravanan666/pypi-org huggingface dataset:
Package: pycompadre-serial
COMpatible PArticle Discretization and REmap ToolkitAboutThe Compadre Toolkit provides a performance portable solution for the parallel evaluation of computationally dense kernels. The toolkit specifically targets the Generalized Moving Least Squares (GMLS) approach, which requires the inversion of small dense matrices. The result is a set of weights that provide the information needed for remap or entries that constitute the rows of some globally sparse matrix.This toolkit focuses on the 'on-node' aspects of meshless PDE solution and remap, namely the parallel construction of small dense matrices and their inversion. What it doesnotprovide is the tools for managing fields, inverting globally sparse matrices, or neighbor search that requires orchestration over many MPI processes. This toolkit is designed to be easily dropped-in to an existing MPI (or serial) based framework for PDE solution or remap, with minimal dependencies (KokkosandKokkosKernels).Generalized Moving Least Squares (GMLS)A GMLS problem requires the specification of a target functional(Compadre::TargetOperation), a reconstruction space(Compadre::ReconstructionSpace), and a sampling functional(Compadre::SamplingFunctional).The Compadre Toolkit is designed to efficiently assemble, factorize, and solve large batches of minimization problems having the form:Wiki InformationDetails about building and using the Compadre toolkit can be found on theWiki.Recent ChangesRecent ChangesInstallationInstallation of Kokkos and KokkosKernels[Either automatically configured and built, or user installation location provided]Installation of CompadreDocumentation and TutorialsThe toolkit is documented by Doxygen.Documentation is available onlineor can be compiled from source.
To compile from source: 1.) install doxygen software on your computer, 2.) execute '>> make doc' after having installed the Compadre Toolkit. HTML and Latex documentation will be generated in thedoc/folder, in-source.Citing the SoftwareIf you write a paper using results obtained with the help of the Compadre Toolkit, please cite the following reference which is applicable to every version of the Compadre Toolkit:@software{compadre_toolkit,
  author       = {Paul Kuberry and
                  Peter Bosler and
                  Nathaniel Trask},
  title        = {Compadre Toolkit},
  month        = jan, 
  year         = 2019,
  doi          = {10.11578/dc.20190411.1},
  url          = {https://github.com/sandialabs/compadre}
}If you are using a particular release of the Compadre Toolkit and would like to help others to reproduce your results, please cite that release specifically. A reference to the most recent release is:@software{compadre_toolkit_v1_5_0,
  author       = {Paul Kuberry and
                  Peter Bosler and
                  Nathaniel Trask},
  title        = {Compadre Toolkit},
  month        = sep,
  year         = 2022,
  publisher    = {Zenodo},
  version      = {v1.5.0},
  doi          = {10.5281/zenodo.7065758},
  url          = {https://doi.org/10.5281/zenodo.7065758}
}! DOI: 10.11578/dc.20190411.1
Package: pycompall
Pycompall PackagePycompall is a wrapper around the defaultcompileallPython utility to compile.pyto.pycfiles to provide a more configurable interface and as a build tool when configuring python files.This package is also useful for code obfuscation, especially since most.pyfiles can be substituted for their compiled bytecode equivalents most of the time.InstallationpipinstallpycompallUsagepycompall compile [OPTIONS] [PATH].Without any options, this will compile all.pyfiles in the current directory (or file) into the default__pycache__directory.Options-r,--recursiveRecurse through subdirectories.--in-placeRemove original.pyfiles and replace them with compiled.pycfiles.--create-empty-initCreate an empty__init__.pyfile in the base directory path specified after compilation. Useful for interacting with other build tools such as colcon that require a package to have an__init__.pyfile.Note: this only adds the file in thebase directoryspecified, regardless of whether the--recursiveflag is specified.--exclude-files TEXTExclude pattern(s) for files to be excluded during                    compilation and replacement.Note: this option supports globbing patterns with python'sPath.matchmethod, but this requires globs to be passed as strings to the tool, so you must wrap the glob in quotes (e.g.pycompall compile --exclude-files '*.py').To specify multiple files to exclude, write the flag again (e.g.pycompall compile --exclude-files '*test.py' --exclude-files 'test/*.py')--exclude-dirs TEXTExclude pattern(s) for directories to be excluded during compilation and replacement. Note that if the directory is skipped and --create-empty-init is True, the__init__.pyfile will not be created.Note: this option supports globbing patterns with python'sPath.matchmethod, but this requires globs to be passed as strings to the tool, so you must wrap the glob in quotes (e.g.pycompall compile --exclude-dirs 'test*').To specify multiple directories to exclude, write the flag again (e.g.pycompall compile --exclude-dirs 'test' --exclude-dirs 'utils')--ignore-symlinksSometimes symlinks causes problems. Enable this flag to ignore symlinks.
Package: pycompat
pycompat [![Build Status](https://travis-ci.org/alexandrevicenzi/pycompat.svg?branch=master)](https://travis-ci.org/alexandrevicenzi/pycompat) ![Build](https://codeship.com/projects/3a276a20-cff5-0132-fff1-7637bc41f5cd/status?branch=master) [![Version](https://img.shields.io/pypi/v/pycompat.svg)](https://pypi.python.org/pypi/pycompat)========Library to check Python and System version in a easy way### CompatibilityWorks with all major versions of Python.Tested on Python 1.5, 2.2, 2.3, 2.4, 2.6, 2.7, 3.0, 3.2, 3.3, 3.4 and PyPy.### Install`pip install pycompat`or`python setup.py install`### How to use?```pythonfrom pycompat import python as py``````pythonpy.is2xx>>> True``````pythonpy.is27x>>> True``````pythonpy.is3xx>>> False``````pythonpy.is_gt(2, 5)>>> True``````pythonpy.is_lt(3)>>> True``````pythonpy.is_eq(2, 7, 5)>>> True``````pythonpy.is_cpython>>> True``````pythonpy.is_pypy>>> False``````pythonfrom pycompat import system as sys``````pythonsys.is_64bits>>> True``````pythonsys.is_linux>>> True``````pythonsys.is_linux2>>> True``````pythonsys.is_linux3>>> False```### List of all attributes/methods```pythonimport pycompatfrom pycompat import python, system# Constantspycompat.WIN_32pycompat.CYGWINpycompat.LINUXpycompat.LINUX2pycompat.LINUX3pycompat.MAC_OS_Xpycompat.OS2pycompat.OS2_EMXpycompat.CPYTHONpycompat.IRONPYTHONpycompat.JYTHONpycompat.PYPYpycompat.MAX_SIZE# Python versionpycompat.majorpycompat.minorpycompat.micropycompat.release# Python infopython.is1xxpython.is10xpython.is15xpython.is16xpython.is2xxpython.is20xpython.is21xpython.is22xpython.is23xpython.is24xpython.is25xpython.is26xpython.is27xpython.is3xxpython.is30xpython.is31xpython.is32xpython.is33xpython.is34xpython.is35xpython.is36xpython.is37xpython.is_pypypython.is_ironpythonpython.is_jythonpython.is_cpythonpython.is_32bitspython.is_64bitspython.is_gt(2, 7, 5)python.is_lt(2, 7, 5)python.is_eq(2, 7, 5)python.is_alphapython.is_betapython.is_candidatepython.is_final# System infosystem.is_windowssystem.is_cygwinsystem.is_linuxsystem.is_linux2system.is_linux3system.is_mac_ossystem.is_32bitssystem.is_64bits```### Changelog#### 0.2.1- Fix [#3](https://github.com/alexandrevicenzi/pycompat/issues/3).#### 0.2- Better approach for `is_lt`, `is_gt` and `is_eq`.- Add Python release info.### Want more?Feel free to request more functions or contribute in this project.
Package: pycompete
pycompetepycompete provides tools to support the training and evaluation of models for theCrunchDAO competition.Installing pycompetepip install pycompeteInteracting with the CrunchDAO tournamentWe recommend using the open-sourceCrunchDAO PythonAPI for pulling data and submitting predictions.To interact with the API, you need set your API key as theCRUNCH_API_KEYenvironment variable:export CRUNCH_API_KEY = YOUR_API_KEYContributingContributions are welcome! Please feel free to raise a PR adding any functionality you think may be useful to other CrunchDAO competitors. If you find a bug please raise an issue and we will try and address.
Package: pycompilation
pycompilation bundles python convenience classes and functions for performing compilation
and linking on the fly from python. Developed to simplify working with code-generation,
compilation and import (meta-programming) from Python.InstallationExample using pip (modify to your own needs):$ python3 -m pip install --user pycompilationExamplesLook atexamples/*_main.pywhich show how pycompilation can be used.You may also look at other projects which uses pycompilation:pycodeexportcInterpolfinitediffsymvarsubDocumentationYou find the latest documentation athttp://pycompilation.readthedocs.org/DependenciesFor the examples to work you need:CythonA C compiler (e.g. gcc)A C++ compiler (e.g. g++)A Fortran complier (e.g. gfortran)appdirs (python module)LicenseOpen Source. Released under the very permissive simplified (2-clause) BSD license.
See LICENSE for further details.TODOWindows supportPGI compilersBetter Intel MKL linkline help (cf. “Intel® Math Kernel Library Link Line Advisor”)
Package: pycompliance
pycomplianceA simply library to represent compliance benchmarks as tree structures.frompycomplianceimportpycompliancebenchmark=pycompliance.Benchmark("CIS Red Hat OpenShift Container Platform")benchmark.version="1.3.0"section=pycompliance.Section("1")section.title="Control Plane Components"benchmark.add_section(section)subsection=pycompliance.Section("1.1")subsection.title="Master Node Configuration Files"benchmark.add_section(subsection)control=pycompliance.Control("1.1.1")control.title="Ensure foobar permissions"benchmark.add_control(control)print(benchmark.find('1.1.1').title)Outputs:Ensure foobar permissions
Package: pycompose
PyComposeA simple way to inject composition through inheritance syntax.InspirationsThe following links served as inpiration during the writing of this, and as a in-depth explanation of what actually is composition and its benefits and drawbacks versus inheritance.Ariel Ortiz's 2019 PyCon talkforwardableExplanationFrom the inspirations one can easily see that an older implementation of compositional forwarding exists (forwardable) so why would I do this to myself? In short, I didn't like the syntax introduced by it. I find the syntax provided by this implementation a bit easier to understand as I find adding things that related to properties of a class inside the brackets in the class statement the most logical.UsagefrompycomposeimportComposeclassA:test1="123"defhello(self):print("A")def__repr__(self):return"<A>"classB:test2="456"defhello(self):print("B")def__repr__(self):return"<B>"classC(Compose(A,"test1",("hello","helloA")),Compose(B,"test2",("hello","helloB"),name="b_object"),):...c=C()print(c.test1+c.test2)# > 123456c.helloA()# > Ac.helloB()# > Bprint(c._a,c.b_object)# > <A> <B>DisclaimerPlease do note that this project is but a small abstraction for something that can easily be achieved only a few more lines of hand written code. As such I am aware of the fact that this may seem pretty useless to some people.
MIT LicenseCopyright (c) 2020 Tim FischerPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: pycomposite
Composite Class DecoratorThis project contains a generic implementation of theComposite Design Patternas a Python class decorator.This is a targeted solution addressing the particular need of creating compositeBuilders. All existing solutions we observed so far assumed manual reproduction on every abstract method in Composite, which is problematic from a maintenance point of view.For more technical in-depth discussion please refer to our article:Generic Composite in PythonUsage ExamplefromabcimportABC,abstractmethodfromtypingimportTuple,AnyfrompycompositeimportcompositeclassConfiguration:'''Just an example to demostrate side-effect'''def__init__(self):self._configuration={}defconfigure(self,name:str,value:Any)->None:self._configuration[name]=valueclassBuilder(ABC):@abstractmethoddefbuild_part_one(self,arg:int)->Tuple:#better coveres a general casepass@abstractmethoddefbuild_part_two(self,arg:str)->Tuple:pass@abstractmethoddefconfigure_part_three(self,arg:Configuration)->None:passclassBuilderA(Builder):defbuild_part_one(self,arg:int)->Tuple:#better coveres a general casereturnarg*10,arg+5,defbuild_part_two(self,arg:str)->Tuple:returnf'A:{arg}',defconfigure_part_three(self,arg:Configuration)->None:arg.configure('A','A builder')classBuilderB(Builder):defbuild_part_one(self,arg:int)->Tuple:#better coveres a general casereturnarg-100,arg*5,defbuild_part_two(self,arg:str)->Tuple:returnf'B:{arg}',defconfigure_part_three(self,arg:Configuration)->None:arg.configure('B','B builder')@compositeclassCompositeBuilder(Builder):passbuilder=CompositeBuilder(BuilderA(),BuilderB())config=Configuration()builder.configure_part_three(config)assert(70,12,-93,35)==builder.build_part_one(7)assert('A: high','B: high')==builder.build_part_two('high')assert{'A':'A builder','B':'B builder'}==config._configuration
Package: pycompressor
pycompressorPackage provides python implementation of string compressorInstallRun the following command to install pycompressor using pip$pipinstallpycompressorUsage:frompycompressor.huffmanimportHuffmanCompressorhuffman=HuffmanCompressor()original='Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry\'s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.'print('before compression: '+original)print('length: '+str(len(original)))compressed=huffman.compress_to_string(original)print('after compression: '+compressed)print('length: '+str(len(compressed)))decompressed=huffman.decompress_from_string(compressed)print('after decompression: '+decompressed)print('length: '+str(len(decompressed)))
Package: pycompss
PyCOMPSs is a framework which aims to ease the development and execution of Python parallel applications for distributed infrastructures, such as Clusters and Clouds.OverviewPyCOMPSs is the Python binding of COMPSs, a programming model and runtime which aims to ease the development of parallel applications for distributed infrastructures, such as Clusters and Clouds. The Programming model offers a sequential interface but at execution time the runtime system is able to exploit the inherent parallelism of applications at task level. The framework is complemented by a set of tools for facilitating the development, execution monitoring and post-mortem performance analysis.A PyCOMPSs application is composed of tasks, which are methods annotated with decorators following the PyCOMPSs syntax. At execution time, the runtime builds a task graph that takes into account the data dependencies between tasks, and from this graph schedules and executes the tasks in the distributed infrastructure, taking also care of the required data transfers between nodes.Official web page:http://compss.bsc.esDocumentationPyCOMPSs documentation can be found athttp://compss.bsc.es(Documentation tab) and athttps://compss-doc.readthedocs.io/en/stable/(See “PIP” section in the Installation and Administration Section)InstallationFirst, be sure that the target machine satisfies the mentioned dependencies on the installation manual.The installation can be done in various alternative ways:Use PIP to install the official PyCOMPSs version from the pypi live repository:$ sudo -E python3 -m pip install pycompss -vUse PIP to install PyCOMPSs from a pycompss-<version>.tar.gz file:$ sudo -E python3 -m pip install pycompss-<version>.tar.gz -vUse the setup.py script:$ sudo -E python3 setup.py installWorkflows and Distributed ComputingDepartment of Computer ScienceBarcelona Supercomputing Center (http://www.bsc.es)
Package: pycompss-cli
IntroductionThe PyCOMPSs CLI (pycompss) provides a standalone tool to use PyCOMPSs interactively within
docker environments, local machines and remote clusters. This tool has been
implemented on top ofPyCOMPSs programming
model, and it is being developed by theWorkflows and Distributed Computing
groupof theBarcelona Supercomputing
Center.ContentsQuickstartLicenseQuickstartThere are two ways in which you can get started with PyCOMPSs. You can
perform a local installation by installing thepycompss
package, or you can use it
through our ready-to-use docker image thorugh thispycompss-cli
tool.Installationpython3-mpipinstallpycompss-cliThis should add the pycompss-cli executables (pycompss,compssanddislib) to your path. They can be used indiferently.Warning:The user executable path may not be automatically exported
into thePATHenvironment variable. So, take this into account if
installed with the--userflag, since thepycompss|compsscommand will be unreachable until the path
is exported intoPATH.Dependencies (Optional)For creating docker environments pycompss-cli currently requires:docker >= 17.12.0-ceInstall dockerpycompss-cli requiresdocker 17.12.0-ceor greater.Follow these instructionsDocker for
Mac.
Or, if you prefer to useHomebrew.Docker for
Ubuntu.Docker for Arch
Linux.Be aware that for some distros the docker package has been renamed
fromdockertodocker-ce. Make sure you install the new
package.Add user to docker group to run pycompss as a non-root user.InstructionsCheck that docker is correctly installeddocker--versiondockerps# this should be empty as no docker processes are yet running.Installdocker-pypython3-mpipinstalldockerUsageFor detailed instructions and examples of usage please visit official documentation.PyCOMPSs-CLI Usage DocumentationLicenseApache License Version 2.0Workflows and Distributed ComputingDepartment of Computer ScienceBarcelona Supercomputing Center (http://www.bsc.es)
Package: pycompute
bzComputebzCompute is a computation graph library with built-in support for domain-decomposition and prallel computation. The library can be used for expressing and executing large number of mathematical and text-processing operations using Data-Flow graphs, (Educational version of tensorflow), written in pure python code with numpy support.Examples :The educational project supports limited number of text-processing and mathematical operations that are normally used frequently.Look at examples folder for various examplesParallel Computation :The librabry supports both sequential and parallel computation on graphs. Domain Decomposition is the computation technique used to provide task-level parallelism by creating replicas of computation graphs . The library creates a Master-worker setup, where the MasterSession creates specified number of worker sessions, each worker-session is a thread. These threads can be pre-forked to memory or can be created on demand. Each worker is automatically assigned a name. The results are collected. Domain decomposition is manily used for running multiple replicas of data-flow graphs on different inputs, check outexamples.Supported Sessions :The library supports three types of sessions as of now :SequentialSession: SequentialSession executes computation graph in a sequential order, leaving parallelism to OS and Hardware.MasterSession: Creates a master session for parallel computation, can be used for domain-decomposition, by specifying number of worker threads.StringSession: It is a variant of SequentialSession for executing a computation graph composed of strign operations.Supported Operations :bzCompute supports many operations as of now, the library also provides support for defining custom operations as per the requirements.Numerical Operations :Look atpyCompute/KernelOperations.pyto obtain list of all supported operationsText-Processing Operations :Look atpyCompute/text_processing/StringOperations.pyfor all supported string operations.
Package: pycompwa
About pycompwapycompwa is a collection of python modules and the python interface toComPWA. ComPWA stands for "Common Partial
Wave Analysis framework".Analogous to ComPWA, pycompwa's highest focus is also modularity. pycompwa
extends the ComPWA framework with some useful modules:expertsystemA python package that can generate amplitude/intensity model files from
simple user boundary conditions, such as initial and final state. Currently
supports the helicity and canonical formalism.uiThe python
interface to ComPWA, allowing easy steering of ComPWA.plottingFacilitates the visualization of data and results, i.e. comparison plots,
Dalitz plots.InstallationDetailed instructions can be foundhere. Make sure the virtual
environment is setup and activated.Installation via pypipipinstallpycompwaInstallation from sourcegitclone--recurse-submodulesgit@github.com:ComPWA/pycompwa.gitcdpycompwa
pythonsetup.pyinstall-j4(replace4with the number of cores on your machine, or use$(nproc)).UsageOn how to use ComPWA please refer to thepycompwa workflow examples.DocumentationThe documentation can be foundhere.
Package: pycomscore
Marketing Science | Omnicom media group | Comscore LibraryDeveloped by the Omnicom Marketing Science teamIntroductionComscore is a platform that allows us to know a little more about the behavior of users within the internet.Thanks to the help of the annalect teams, we have all the information available in our databases.For this reason, we generate a module that allows consulting the data without having to know SQL.You can run the different modules of the package through the following link:https://colab.research.google.com/drive/1DAQus4KWhL38OQeTMGLpCACMcmHi99Z9?usp=sharingHowever, if you know about python, this package allows you to further customize and standardize your queries, creating programs that execute them periodically.pipinstallpycomscorefrompycomscoreimportcomscore_omnicom_databasecoms_obj=comscore_omnicom_database(user='user',password='pass')Here are some examples of the first methods.dataframe_geo=coms_obj.demographics_by_web(country='mx',start_date='2020-01-01',end_date='2020-12-31',event_like='atv',domain='brp.com',saved=False,age_group=True,ages_between=None,gender_between=None)dataframe_geo.head(15)# countries ['us','ar', 'au','br', 'ca', 'cl', 'co', 'hk', 'id', 'in', 'mx', 'my', 'nz', 'sg', 'tw']all_probabilities,short_frame_probabilities=coms_obj.bayesian_inference_over_sites(country='cl',domain='sodimac.cl',time_spent=300,start_date='2021-01-01',end_date='2021-05-01')short_frame_probabilities.head(15)If you have any advice, you can write to our team via email atdata.analitica@omnicommediagroup.com