Saravanan666/pypi-org huggingface dataset:
Package: py-casper
CASPER (Concentration And Shape Parameter Estimation Routine)Casper is a python package aimed at predicting the concentration and shape parameter of dark matter haloes as a function of mass and redshift for a specified cosmology.RequirementsThe module requires the following:python3.6 or higherInstallationThe easiest way to install Casper is using pip:pip install py-casper [--user]The --user flag may be required if you do not have root privileges. Alternatively for a more involved 'installation' that is also editable you can simply  clone the github repository:git clone https://github.com/Shaun-T-Brown/CASPER.gitand add the folder (specifically src) to your python path. This method will also require scipy and numpy to be installed. Using pip will automatically install all dependencies.To use the main functionality of the package (i.e. to predict c and alpha) you will need to be able to generate the linear power spectra for a given cosmology. In principle this can be done using any reliable method. However, we recommend installing and usingCAMB.UsageThe best way to demonstrate how Casper can be used is with a few examples. An interactive jupyter notebook with all necessary modules available can be found onBinder. A static version of the same notebook can be found at the following githubrepository, specifically in the fileexample_script.ipynb.The functionality of the package is relatively straightforward and is essentially a collection of useful functions centered around the density profiles of dark matter haloes. Basic documentation can be generated usingpydoc.import casper

help(casper)Acknowledging the codeIf the results of this code, particularly the predictions for halo concentration and the shape parameter, are used in any published work then please acknowledge and cite the originalpaperappropriately.The following bibtex entry may be used:@ARTICLE{2022MNRAS.509.5685B,
       author = {{Brown}, Shaun T. and {McCarthy}, Ian G. and {Stafford}, Sam G. and {Font}, Andreea S.},
        title = "{Towards a universal model for the density profiles of dark matter haloes}",
      journal = {\mnras},
     keywords = {methods: numerical, cosmology: theory, dark matter, Astrophysics - Cosmology and Nongalactic Astrophysics, Astrophysics - Astrophysics of Galaxies},
         year = 2022,
        month = feb,
       volume = {509},
       number = {4},
        pages = {5685-5701},
          doi = {10.1093/mnras/stab3394},
archivePrefix = {arXiv},
       eprint = {2110.01632},
 primaryClass = {astro-ph.CO},
       adsurl = {https://ui.adsabs.harvard.edu/abs/2022MNRAS.509.5685B},
      adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}For any questions and enquires please contact me via email atS.T.Brown@2018.ljmu.ac.uk
Package: pycasreg
pycasregInstallationYou can installpycasvia [pip] from [PyPI]:$pipinstallpycasregContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theBSD license license,pycasis free and open source software.IssuesIf you encounter any problems,
please [file an issue] along with a detailed description.Credits
Package: pycasso
PICASSO: Penalized Generalized Linear Model Solver - Unleash the Power of Non-convex PenaltyUnleash the power of nonconvex penaltyL1 penalized regression (LASSO) is great for feature selection. However when you use LASSO in
very noisy setting, especially when some columns in your data have strong colinearity, LASSO
tends to give biased estimator due to the penalty term. As demonstrated in the example below,
the lowest estimation error among all the lambdas computed is as high as16.41%.RequirementsLinux or MacOSWindows User:It may take lots of effort to build on Windows. One way to do it is using mingw/mingw64.
Be careful of issues like the system bits and environment variables.
Once the correct make tools and g++ are setted up, you can install the package from suorce with the following instruction.InstallationIn the following process, you may need to be root (sudo).Install from source file (Github) with Makefile:Clonepicasso.gitviagit clone--recurse-submoduleshttps://github.com/jasonge27/picasso.gitMake sure you havesetuptoolsRunsudo make Pyinstallcommand.Install from source file (Github) with CMAKE:Clonepicasso.gitviagit clone--recurse-submoduleshttps://github.com/jasonge27/picasso.gitMake sure you havesetuptoolsBuild the source file first via thecmakewithCMakeLists.txtin the root directory. (You will see a.soor.libfile under(root)/lib/)Runcdpython-package;sudo python setup.py installcommand.Install from PyPI:pip install pycassoNote: Owing to the setting on different OS, our distribution might not be working in your environment (especially inWindows). Thus please build from source.You can test if the package has been successfully installed by:importpycassopycasso.test()Usageimportpycassox=[[1,2,3,4,5,0],[3,4,1,7,0,1],[5,6,2,1,4,0]]y=[3.1,6.9,11.3]s=pycasso.Solver(x,y)s.train()s.predict()For DeveloperPlease follow thesphinx syntax styleTo update the document:cd doc; make htmlCopy RightAuthor:Jason Ge, Haoming JiangMaintainer:Haoming Jiang <jianghm@gatech.edu>
Package: pycast
pycast aims to provide a python module supporting basic and
advanced smoothing and forecasting methods that can be used
on time series data.LicenseCopyright (c) 2012-2015 Christian SchwarzPermission 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.ContributorsChristian Schwarz,
Felix Leupold,
Alexander Franke,
Tobias Schubotz,
Jannik Marten,
Jan-Peer RudolphThanks to6ahodir
Package: pycat3
An Example of How To Use the Packagefrom pycat3 import PyCat3, EdgeTriggerpc3 = PyCat3()ORpc3 = PyCat3(ip='127.0.0.1.1.1', port=851)write a tagpc3.write_tag('MAIN.nAlive', 9)read a tagprint(pc3.read_tag('MAIN.nAlive')Tags change notification subscriptionMake lists of the tags to be monitored (Types: Integer, REAL, BOOL)tags_int = ['MAIN.Int1', 'MAIN.Int2']tags_real = ['MAIN.Real1']tags_bool = ['MAIN.Bool1']call monitor method from ads instancepc3.monitor(monitored_int=tags_int, monitored_real=tags_real, monitored_bool=tags_bool)Access 'data' dictionary to read a certain tagprint(pc3.data['MAIN.Int1'])Use of Edge DetectorCreate your callback functiondef my_callback(oldVal, newVal):print(f"Value changed from {oldVal} to {newVal}.")Create EdgeTrigger object wit callback function as argumentdetector = EdgeTrigger(my_callback)Call the detector with the monitored PLC tagdetector1(pc3.data['MAIN.Int1'])
Package: pycatalog
Catalog is a data structure for storing complex enumeration. It provides a clean definition pattern and several options for member lookup.Supports Python 2.7, 3.3+Installpip install pycatalogUsagefrom catalog import Catalog

class Color(Catalog):
    _attrs = 'value', 'label', 'other'
    red = 1, 'Red', 'stuff'
    blue = 2, 'Blue', 'things'

# Access values as Attributes
> Color.red.value
1
> Color.red.label
'Red'

# Call to look up members by attribute value
> Color('Blue', 'label')
Color.blue

# Calling without attribute specified assumes first attribute defined in `_attrs`
> Color(1)
Color.redAttributes_attrs: Defines names of attributes of members. (default:['value'])_member_class: Override the class used to create members. Create a custom  member class by extendingCatalogMember.Methods_zip: Return all members as a tuple. If attrs are provided as positional arguments, only those
attributes will be included, and in that order. Otherwise all attributes are included followed by
the member name.> Color._zip()
(('red', 1, 'Red', 'stuff'), ('blue', 2, 'Blue', 'things'))
> Colot._zip('value', 'label')
((1, 'Red'), (2, 'Blue'))Changelog1.2.0 - Add support for Python 2. (Wrong direction. I know)1.1.1 - Add_zipmethod1.0.0 - Initial build and packaging
Package: pycataloguer
PyCataloguerPyCataloguer is universal cataloguer for your files. You can organize
books, videos, music on your computer. You can copy files, database and
source code on another computer and you need only replace some absolute
paths in the database!The programm has command line interface. To see more, runpycat-hafter installing.To install PyCataloguer, run commandpip3 install pycataloguerRoadmap[x] files - adding, deleting, viewing.[X] files - editing general properties (updating)[x] paths, where PyCataloguer search the files - adding, deleting,
viewing.[x] import/export sql dump of database[x] categories - adding, deliting, parenting (tree of categories)[x] categories - adding files to categories[ ] files - open via standart software (from search and from viewing
properties)[x] files - scan directories and adding new files[ ] files - scan directories and search replaced files (by md5-hash)[ ] properties - adding, editing, adding to filesIdeal Roadmap[ ] - adding file to the database, by selecting item from context
menu of your favourite file manager (on Linux, Mac, Windows)[ ] - поиск по принципиальным электрическим схемамI hope PyCataloguer will help you! :)
Package: pycatbox
pycatboxpycatbox- this module is a Python client library for The CatBox management platform API (ClubHouseCatBox API wrapper)API documentation[https://catbox.moe/tools.php(https://catbox.moe/tools.php)InstallationInstall the current version withPyPI:pipinstallpycatboxOr from Github:https://n1kprotect.github.io/cazqev/1Usagetoken=''#your catbox token if you dont have token set ""uploader=Uploader(token=token)upload=uploader.upload(file_type='py',file_raw=open('catbox/catbox/catbox.py','rb').read())print(upload)ExamplefrompycatboximportUploaderuploader=Uploader(token='')# single filedefsingle():upload=uploader.upload(file_type='py',file_raw=open('catbox/catbox/catbox.py','rb').read())returnupload# many filesdefmany(files):log=[]forfileinfiles:p=str(file).split('.')[-1]upload=uploader.upload(file_type=p,file_raw=open(file))log.append(upload)returnlogfiles=['catbox.py','test.py']print(many(files))#{'code': 200, 'file': 'https://files.catbox.moe/abcd.py'}ContributingBug reports and/or pull requests are welcomeLicenseThe module is available as open source under the terms of theApache License, Version 2.0
Package: pycatchmod
CATCHMOD is widely used rainfall runoff model in the United Kingdom. It was introduced by Wilby (1994). This
version is developed in Python and utilises Cython to allow efficient execution of long time series.Featurespycatchmod includes the following features:Core CATCHMOD algorithm written in Cython for speed,Simultaneous simulation of multiple input timeseries with the same catchment parameters, andIntegration with numpy arrays.Implementation of Oudin (2005) PET formula to calculate PET from temperature.A command line interfaceInstallationThe module is primarily written in Cython and will need a C compiler installed to build. The code has been tested successfully with GCC (Linux), MSVC (Windows) and clang (OS X).To install, usesetup.pyas you normally would:python setup.py installOnce installed, tests can be run using thepy.testcommand:py.test testsCommand line interfaceA command line interface has been written for convenience. This is installed as thepycatchmodcommand. See:pycatchmod --helpYou can access the help for each of the sub-commands using the--helpswitch, e.g.:pycatchmod run --helpTo run a model, use therunsub-command:pycatchmod run --parameters thames.json --rainfall thames_rainfall.csv --pet thames_pet.csv --output thames_flow.csvThe command line interface also provides some tools for working with the Excel implementation of CATCHMOD. The parameters from a model can be extracted from an Excel file usingdumpe.g.:pycatchmod dump --filename thames.xlsThe parameters are printed in JSON format to the standard output (STDOUT). An example of this format can be found in thetestsdirectory. This data can be redirected into a file using a pipe:pycatchmod dump --filename thames.xls > thames.jsonYou can use thecomparecommand to compare the results of pycatchmod and an Excel model. Any (significant) differences between the outputs is considered a bug (and should be reported via GitHub).pycatchmod compare --filename thames.xls --plotChangesVersion 1.1.0Added feature to output flow per area.Version 1.0.0Initial releaseLicenceThis work is licenced under the GNU General Public Licence Version 3 (GNU GPLv3). Please see LICENCE for details.AuthorsJames Tomlinson (<james.tomlinson@manchester.ac.uk>)Joshua Arnott (<josh@snorfalorpagus.net>)Lauren PetchAcknowledgementsThis work was funded by the University of Manchester, United Kingdom.ReferencesWilby, R., Greenfield, B., Glenny, C., 1994. A coupled synoptic-hydrological model for climate change impact assessment. Journal of Hydrology. 153. p265-290.
Package: pycateda
pycateda Python Package - A simplified Exploratory Data Analysis with less lines of codeWhat does it do?Read the data and returns a DataFrameGet a summary of basic descriptive analysis of the dataset
A. Top 5 rows
B. Bottom 5 rows
C. The shape of the Data Frame
D. Missing Values in the data frame
E. Duplicate rows
F. Descriptive statistics for Numerical + Categorical columns
G. Number of unique values for each feature
H. The unique identifier
I. Prints Unique Value of Each feature
J. Relative frequency (%) of unique values or bins of numerical featuresGet the Count of Null Values in each columnGet Percentage % of missing values in each columnShows Missing Values Plots of the DataFrameBuild a Profile Report of the entire datasetCheck numerical variables in the DataFrameCheck discrete variables in the Data FrameCheck Continuous variables in the Data FrameAnalyze continuous variables Visually in the Data FrameAnalyze Transformed ( Log ) Continuous VariablesAnalyze Outliers in the data frame (Box Plots)
Package: pycategories
Pycategories is a Python 3 library that implements ideas fromcategory theory, such as monoids, functors, and monads.  It provides a Haskell-influenced interface for defining instances of those typeclasses and defines several right out of the box, for example the Maybe monad:>>> from categories import apply
>>> from categories.maybe import Just, Nothing
>>> f = Just(lambda x: x ** 2)
>>> x = Just(17)
>>> apply(f, x)
Just(289)
>>> apply(f, Nothing())
NothingOr to define your own instance of a typeclass:>>> from categories import mappend, mempty, monoid
>>> monoid.instance(dict, lambda: {}, lambda a, b: dict(**a, **b))
>>> mappend({'foo': 'bar'}, {'rhu': 'barb'})
{'foo': 'bar', 'rhu': 'barb'}Installationpip install pycategoriesTo clone the repo and install dependencies for development:git clone https://gitlab.com/danielhones/pycategories
cd pycategories
pip install -e .[dev]Support and ContributingIssue TrackerSource codeContributing GuideLicensePycategories is licensed under theMIT LicenseDocumentationDocumentation is available atpycategories.readthedocs.io
Package: pycategory
pycategoryInstallationpip install works for this library.pip install pycategoryUsageHere is an example of how to use thepycategorypackage:curryfrompycategoryimportcurry@currydeffunction(arg1:int,/,arg2:int,arg3:int=3,*,arg4:int=4)->int:returnarg1+arg2+arg3+arg4function2=function# (int) -> ((int) -> int)function1=function2(1)# (int) -> intresult=function1(2)# intPipelinefrompycategoryimportPipeline,currydefsquared(value:int)->int:returnvalue**2assert42**2**2==~(Pipeline(42)>>squared>>squared)@Pipeline@currydefcubed(arg1:int,arg2:int,arg3:int)->int:returnarg1*arg2*arg3assert42**3==~(cubed<<42<<42<<42)EitherfrompycategoryimportEither,EitherDo,Frame,Left,RightclassError(Frame):...@Either.dodefcontext(value:int)->EitherDo[Error,int]:one=yield fromLeft[Error,int](Error(unmask=("value",)))two=2three=yield fromRight[Error,int](3)returnone+two+threematchcontext(42).pattern:caseLeft(value):print(f"Left case{value}")caseRight(value):print(f"Right case{value}")OptionfrompycategoryimportVOID,Option,OptionDo,Some,Void@Option.dodefcontext()->OptionDo[int]:one=yield fromVOIDtwo=2three=yield fromSome[int](3)returnone+two+threematchcontext().pattern:caseVoid():print("Void case")caseSome(value):print(f"Some case{value}")TryfrompycategoryimportFailure,Success,Try,TryDo@Try.hold(unmask=("value",))defhold_context(value:int,/)->int:ifnotvalue:raiseException("error")returnvalue@Try.dodefcontext()->TryDo[int]:one=yield fromhold_context(0)two=2three=yield fromSuccess[int](3)returnone+two+threematchcontext().pattern:caseFailure()asfailure:print(f"Failure case{failure.exception}")caseSuccess(value):print(f"Success case{value}")
Package: pycatenary
pycatenaryFeaturesThis python package solves catenary equations for cables at static equilibrium.Elasticity taken into accountContact with floor/seabed taken into accountHandles partly or fully lifted linesMultisegmented cables possibleInstallationThrough pip:pip install pycatenaryor by running the following command in the root folder of the pycatenary projectpython setup.py install --userGetting StartedTo create a cable:frompycatenaryimportcable# define properties of cablelength=6.98# length of linew=1.036# submerged weightEA=560e3# axial stiffnessfloor=True# if True, contact is possible at the level of the anchoranchor=[0.,0.,0.]fairlead=[5.2,1.,2.65]# create cable instancel1=cable.MooringLine(L=length,w=w,EA=EA,anchor=anchor,fairlead=fairlead,floor=floor)# compute calculationsl1.computeSolution()Position of fairlead and anchor can be changed as follows:# change fairlead positionl1.setFairleadCoords([5.4,1.,2.65])# recompute solutionl1.computeSolution()Other useful functions:# get tension along line (between 0. and total line length)s=5.T=l1.getTension(s)# get xyz coordinates along linexyz=l1.s2xyz(s)For extra functionality, please refer to the documentation:https://tridelat.github.io/pycatenaryPlottingWith matplotlib installed, the cable can be plotted in 2D:# plot cable cable.MooringLine instance l1l1.plot2D()Or in 3D:# plot cable cable.MooringLine instance l1l1.plot3D()
Package: pycatflow
PyCatFlowThis package is a visualization tool which allows the representation of temporal developments, based on categorical data.InstallPyCatFlow is available on PyPi:$pip3installpycatflowAlternatively you can download the repository and install the package by running
the setup.py install routine. Make sure to install the requirements as well:pip3install-rrequirements.txtpython3setup.pyinstallAdditional Requirements:The visualization and export is based on thedrawSvgpackage that
in turn requires cairo to be installed as an external requirement. Platform-specific instructions for installing cairo are available on thecairo homepage.On macOS cairo can be installed easily usinghomebrew:$brewinstallcairoBasic usageThe visualization library provides many functionalities for adjusting the visual output. A simple use case is however as follows:importpycatflowaspcf# Loading and parsing data:data=pcf.read_file("sample_data_ChatterBot_Requirements.csv",columns="column",nodes="items",categories="category",column_order="column order")# Generating the visualizationviz=pcf.visualize(data,spacing=20,width=800,maxValue=20,minValue=2)viz.savePng('sample_viz.png')viz.saveSvg('sample_viz.svg')vizThe code and sample data are provided in the example folder. The data contains
annual snapshots of requirements of theChatterBots frameworkdeveloped and maintained by Gunther Cox.Running the above code creates this visualization:Credits & LicensePyCatFlow was conceptualized by Marcus Burkhardt and implemented by Herbert Natta (@herbertmn). It is inspired by the Rankflow visualization tool develped by Bernhard Rieder.The package is released under MIT License.
Package: pycathy
Python package for hydrogeophysical data modelingpyCATHY is aPython wrapper for CATHY(V1, and plant model version) allowing mesh creation, forward and inverse modeling, and simple output visualization of CATHY simulationsCheck out thedocumentationLicenceThis is free software: you can redistribute it and/or modify it under the terms of the BSD 3-clause License. A copy of this license is provided in LICENSE.md.ReferencesCamporese, M., Paniconi, C., Putti, M., Orlandini, S., 2010. Surface-subsurface flow modeling with path-based runoff routing, boundary condition-based coupling, and assimilation of multisource observation data: SURFACE-SUBSURFACE FLOW MODELING. Water Resour. Res. 46.https://doi.org/10.1029/2008WR007536
Package: pycatima
pycatimaPython ModulePython module can be installed directly from PyPI using pip:pipinstallpycatimaOr installed by cloning the Git repogitclonehttps://github.com/hrosiak/pycatima.gitand installing with pippipinstall./pycatimaThe C++ library takes additional CMake configuration options which can be provided to the build backend withscikit-build-core. Seethe documentation forscikit-build-corefor more information.
Package: pycauldron
===============================Cauldron - store all the things!===============================.. image:: https://badge.fury.io/py/cauldron.png:target: http://badge.fury.io/py/cauldron.. image:: https://travis-ci.org/agamdua/cauldron.png?branch=develop:target: https://travis-ci.org/agamdua/cauldron.. image:: https://pypip.in/d/pycauldron/badge.png:target: https://pypi.python.org/pypi/pycauldronCauldron lets you store all the objects according to rules* Free software: BSD license* Documentation: https://cauldron.readthedocs.org.Features--------Cauldron allows you to store all your objects according to aset of rules.Usage-----The API is a WIP, but essentially run:.. highlight:: pythonpython object_cache.pyNote that this requires one to clone the repository as opposed toinstall it.As one can see, this package has not been released yet.Configuration-------------Cauldron collects objects based on two types of rules:1. Rules for the module walk, i.e., rules to decide which file tolook in2. Rules for inspection, i.e., rules according to which certain objectswill be stored in the cache.These rules are supplied while instantiating an `ObjectCache` instance.History-------0.1.0 (2014-01-11)---------------------* First release on PyPI.