Saravanan666/pypi-org huggingface dataset:
Package: causaltensor
CausalTensorCausalTensor is a python package for doing causal inference and policy evaluation using panel data.What is CausalTensorCausalTensor is a suite of tools for addressing questions like "What is the impact of strategy X to outcome Y" given time-series data colleting from multiple units. Answering such questions has wide range of applications from econometrics, operations research, business analytics, polictical science, to healthcare. Please visit ourcomplete documentationfor more information.Installing CausalTensorCausalTensor is compatible with Python 3 or later and also depends on numpy. The simplest way to install CausalTensor and its dependencies is from PyPI with pip, Python's preferred package installer.$ pip install causaltensorNote that CausalTensor is an active project and routinely publishes new releases. In order to upgrade CausalTensor to the latest version, use pip as follows.$ pip install -U causaltensorUsing CausalTensorWe have implemented the following estimators including the traditional method Difference-in-Difference and recent proposed methods such as Synthetic Difference-in-Difference, Matrix Completion with Nuclear Norm Minimization, and De-biased Convex Panel Regression.EstimatorReferenceDifference-in-Difference (DID)Implemented through two-way fixed effects regression.De-biased Convex Panel Regression (DC-PR)Vivek Farias, Andrew Li, and Tianyi Peng. "Learning treatment effects in panels with general intervention patterns." Advances in Neural Information Processing Systems 34 (2021): 14001-14013.Synthetic Difference-in-Difference (SDID)Dmitry Arkhangelsky, Susan Athey, David A. Hirshberg, Guido W. Imbens, and Stefan Wager. "Synthetic difference-in-differences." American Economic Review 111, no. 12 (2021): 4088-4118.Matrix Completion with Nuclear Norm Minimization (MC-NNM)Susan Athey, Mohsen Bayati, Nikolay Doudchenko, Guido Imbens, and Khashayar Khosravi. "Matrix completion methods for causal panel data models." Journal of the American Statistical Association 116, no. 536 (2021): 1716-1730.Please visit ourdocumentationfor the usage instructions. Or check the following simple demo as a tutorial:Panel Data ExamplePanel Data with Multiple TreatmentsMC-NNM with covariates and missing data
Package: causal-test-again
Experimentation LibraryWe are thrilled you decided to contribute to Doordash Experiment Library!Doordash Experimentation Library Dev Environment setupPythonThe easiest way to install the python version for this project is to usepyenv. Follow these steps:brew install pyenvAdd pyenv initializer to shell startup script~/.bash_profile:echo 'eval "$(pyenv init -)"' >> ~/.bash_profilepyenv install 3.8.10pyenv shell 3.8.10To confirm that you have the right python version, simply runpythonin your terminal. This codebase should work with any Python ~3.8 versionPackage dependenciesTo install package depenencies, follow these steps:make install-deps. This command will do the following:It wil create a virtual environment in the root of the project.It will install poetry, which is being used for dependency management and package developmentPoetry will install all the dependencies frompoetry.lockfileIt will install pre-commit hooks that are used for linting and formatting.Set up artifactory config by runningpoetry config http-basic.artifactory username passwordwith your artifactory username and passwordIf you want to update your dependencies, you can runpoetry update.Other make commandsmake shell: will start a bash terminal inside the container based ofDockerfilefound in the project directory. This can be useful for running code in a more isolated environment that mimicks the CI/CD system.make local-build: this will build the sdist and the wheel for the library and put them indistdirectory.make unittest: this will run tests locallyTo perform development in a container using VsCode, please follow thisguide.LicenseThis library is released under the Apache 2.0 license. SeeLICENSEfor details.
Package: causal-testing-framework
Causal Testing FrameworkA Causal Inference-Driven Software Testing FrameworkCausal testing is a causal inference-driven framework for functional black-box testing. This framework utilises
graphical causal inference (CI) techniques for the specification and functional testing of software from a black-box
perspective. In this framework, we use causal directed acyclic graphs (DAGs) to express the anticipated cause-effect
relationships amongst the inputs and outputs of the system-under-test and the supporting mathematical framework to
design statistical procedures capable of making causal inferences. Each causal test case focuses on the causal effect of
an intervention made to the system-under test. That is, a prescribed change to the input configuration of the
system-under-test that is expected to cause a change to some output(s).InstallationSee the Read the Docs site forinstallation
instructions.DocumentationFurther information on causal inference, the code, usage and more can be found on thedocs
Package: causal-tree-learn
CTLChristopher Tran, Elena Zheleva,"Learning Triggers for Heterogeneous Treatment Effects", AAAI 2019.Our method is based on and adapted from:https://github.com/susanathey/causalTreeRequirementsPython 3sklearnscipygraphviz (if you want to plot the tree)Installationthrough pippipinstallcausal_tree_learnor clone the repositorypythonsetup.pybuild_ext--inplaceDemo CodeTwo demo codes are available to run.pythonbinary_example.pyRuns the tree on a binary example (asthma.txt)pythontrigger_example.pyRuns a tree on a trigger problem where the treatment is continuous (note for now the example is made up and treatment does not affect outcome, this is only to show example code)
Package: causalty
This repo contains Python implementations of methods described in the following:Dynamics of event‐related causality in brain electrical activity
(Korzeniewska et al. 2008)https://doi.org/10.1002/hbm.20458The MVGC multivariate Granger causality toolbox: A new approach to Granger-causal inference (Barnett and Seth 2014)https://doi.org/10.1016/j.jneumeth.2013.10.018
Package: causalvis
causalvisA Custom Jupyter Widget LibraryInstallationTo install use pip:$ pip install causalvisFor a development installation (requiresNode.jsandYarn version 1),$ git clone https://github.com//causalvis.git
$ cd causalvis
$ pip install -e .
$ jupyter nbextension install --py --symlink --overwrite --sys-prefix causalvis
$ jupyter nbextension enable --py --sys-prefix causalvisWhen actively developing your extension for JupyterLab, run the command:$ jupyter labextension develop --overwrite causalvisThen you need to rebuild the JS when you make a code change:$ cd js
$ yarn run buildYou then need to refresh the JupyterLab page when your javascript changes.
Package: causar
CausarA high level testing framework for Disnake botsWritten for my needs, open source for yours.Currently still in extremely early development so don't expect a lot.SupportWant realtime help? Join the discordhere.FundingThis project is built entirely around my current personal & freelance needs,
therefore it only covers the areas of Disnake I wish to test. If you want
this package to support further areas of Disnake consider
sponsoring mehere
Package: caustics
causticsThe lensing pipeline of the future: GPU-accelerated,
automatically-differentiable, highly modular. Currently under heavy development:
expect interface changes and some imprecise/untested calculations.InstallationSimply install caustics from PyPI:pipinstallcausticsMinimal Exampleimportmatplotlib.pyplotaspltimportcausticsimporttorchcosmology=caustics.FlatLambdaCDM()sie=caustics.SIE(cosmology=cosmology,name="lens")src=caustics.Sersic(name="source")lnslt=caustics.Sersic(name="lenslight")x=torch.tensor([#   z_s  z_l   x0   y0   q    phi     b    x0   y0   q     phi    n    Re1.5,0.5,-0.2,0.0,0.4,1.5708,1.7,0.0,0.0,0.5,-0.985,1.3,1.0,#   Ie    x0   y0   q    phi  n   Re   Ie5.0,-0.2,0.0,0.8,0.0,1.,1.0,10.0])# fmt: skipminisim=caustics.Lens_Source(lens=sie,source=src,lens_light=lnslt,pixelscale=0.05,pixels_x=100)plt.imshow(minisim(x,quad_level=3),origin="lower")plt.axis("off")plt.show()Batched simulatornewx=x.repeat(20,1)newx+=torch.normal(mean=0,std=0.1*torch.ones_like(newx))images=torch.vmap(minisim)(newx)fig,axarr=plt.subplots(4,5,figsize=(20,16))forax,iminzip(axarr.flatten(),images):ax.imshow(im,origin="lower")plt.show()Automatic DifferentiationJ=torch.func.jacfwd(minisim)(x)# Plot the new imagesfig,axarr=plt.subplots(3,7,figsize=(20,9))fori,axinenumerate(axarr.flatten()):ax.imshow(J[...,i],origin="lower")plt.show()DocumentationPlease see ourdocumentation pagefor more detailed information.ContributionWe welcome contributions from collaborators and researchers interested in our
work. If you have improvements, suggestions, or new findings to share, please
submit an issue or pull request. Your contributions help advance our research
and analysis efforts.To get started with your development (or fork), click the "Open with GitHub
Codespaces" button below to launch a fully configured development environment
with all the necessary tools and extensions.Instruction on how to contribute to this project can be found in the
CONTRIBUTION.mdSome guidelines:Please useisortandblackto format your code.UseCamelCasefor class names andsnake_casefor variable and method
names.Open up issues for bugs/missing features.Use pull requests for additions to the code.Write tests that can be run bypytest.Thanks to our contributors so far!
Package: ca-util
Clean Architecture UtilitesUtility class for building Python projects based on clean architecture.Free software: MIT licenseDocumentation:https://ca-util.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-01-02)First release on PyPI.
Package: cavalry
CAVALRYQuickly load secrets as environment variablesGetting Startedpip3installcavalryUsageRuncav -hto see options. Note: the script is not POSIX compatible and requires/bin/bash.Loading variablesTheloadcommand will run an eval on the variables exported from the function. To get these into your current scope, the file must be run withsource .... Shorthand in most terminals is to simply prepend a dot:. cav load ....TL;DR: to load variables, run. cav load ...usage:cav[-h][-sFILE]{store,delete,load,list,clear}...

Utilitytoloadenvironmentvariables.Topersistthevariablesintoyour
scope,run'source cav {load,clear} [options]'or'. cav {load,clear} [options]'positionalarguments:{store,delete,load,list,clear}storestorevariablesdeletedeletevariablesloadloadvariableslistliststoreddataclearclearvariablesfromenvironment

optionalarguments:-h,--helpshowthishelpmessageandexit-sFILE,--secretsFILEspecifyanalternatesecretsfile© 2020 Sean Christians
Package: cavasspy
CAVASSPPYCAVASS python APIs.Usagefrom cavasspy.ops import *Note that running cavass commands requires the following shell environment configs: PATH including CAVASS build path and VIEWNIX_ENV.
If the shell does not include these configs by default, set cavasspy.ops.CAVASS_PROFILE_PATH to your CAVASS build path (default path is ~/cavass-build in installation if you didn't make any change) before performing CAVASS commands.
Package: caveclient
CAVEclientThis repository supplies client side code to interact with microservices
in the Connectome Annotation Versioning Engine (CAVE).InstallationCan be installed from pypipip install caveclientDocumentationYou can find full documentation on readthedocs (https://caveclient.readthedocs.io).Usage examplesTutorial notebook for accessing the FlyWire Connectome dataset:https://github.com/seung-lab/FlyConnectome/blob/main/CAVE%20tutorial.ipynb
Package: cavefinder
CaveFinderThis is a simple tool to look for code caves of desired dimension into an executable file and optionally can inject a payload into the found caves.CaveFinder supports three types of executables:ElfMachOPeInstallationThe package can be installed through pip:$ pip install cavefinderor downloaded fromGitHub.LicenseMade with :heartpulse: byJDLand released underGPL3 license.
Package: cavejohnson
CaveJohnson is a program to teach XCode6 Server new tricks. It’s a set of commands that perform various commonly-used tasks in a continuous build system. While designed primarily for use inside an XCS trigger script, many of the commands are useful to other build systems (Jenkins, TeamCity, etc.) because the author is unusually good at reverse-engineering and duplicating weird Xcode behavior.In true Unix style, these commands can all be used separately:Build status reporting to GitHubDetecting the GitHub repo and git sha of the current XCS integrationSet the CFBundleVersion based on the XCS integration numberRe-sign an IPA with a new provisioning profile and certificateInstall a mobile provisioning profile to XCSResolve missing SwiftSupport that prevent builds from being processed correctly in iTunesConnectGenerate .symbols files so iTunesConnect symbolicates your crash reportsSubmit to iTunesConnect (new TestFlight) so you can get fully automatic deploymentsSubmit to HockeyApp
Package: cavelink
About Cave-LinkCave-link is a radio device able to transmit data from a cave. You can
add some measurement sensors. The data is consolidated on creator’s
server (database) and displayed through a webpage where the data is dump
to, asthis example shows.If you own a Cavelink, you should ask Felix Ziegler to get your
specific URL, for the sensors you have.If you know nothing about Cavelink system, the officialwebsiteis
the good place to start. Or maybe, you can also begin withWikipedia.What is this repository for?This python module gather the data by parsing the webpage. You will
then be able to display the data on your dashboard or store it to your
own database. I also provide code samples to better explain this -see
directory ‘samples’-.How do I get set up?To ensure a proper setup, I recommend the use of virtualenv (but
optionnal).sudo pip install cavelinkThen you can use the module that way:fromcavelinkimportcavelinkasclwebpage="http://www.cavelink.com/cl/da.php?s=142&g=10&w=1&l=10"nb_rows=5cavelink=cl.Sensor(webpage,nb_rows)motiers=cavelink.getJSON(datefmt='human')# or datefmt='epoch'print(motiers)You will get a the measurements and the sensor details formatted in JSON.{
   "measures": {
      "22.12.2018 16:00": 6.3,
      "22.12.2018 16:30": 5.67,
      "22.12.2018 17:00": 6.0,
      "22.12.2018 17:30": 5.45,
      "22.12.2018 18:00": 5.87
   },
   "sensor": {
      "group": "10",
      "number": "1",
      "station": "142",
      "unit": "C"
   }
}You can also fetch additionnal information, also available from the page.
Please note that the following data is provided in JSON object as well.
This is:>>> print(cavelink.station)
>>> print(cavelink.group)
>>> print(cavelink.number)
>>> print(cavelink.unit)To parse the measures, you can use this sample:importjson# convert the json-formatted string to a python dictionnaymotiers_json=json.loads(motiers)# parse measuresfortimestampinmotiers_json['measures']:print('%s->%s%s'%(timestamp,motiers_json['measures'][timestamp],motiers_json['sensor']['unit']))Contribution guidelinesFeel free to submit issue or better, some pull requests !ContributorsSébastien Pittet (main contributor)Loïc, Bruno and other friends athttps://www.exoscale.comWho do I talk to?sebastien at pittet dot org
Package: caveman
Caveman is a package that parses and validatesHTML5 cache manifests.  HTML5
applications are notoriously picky about their cache manifests, and it is
difficult to check that all of the components are as they should be.Caveman provides one command-line script,check_manifest, which pulls an HTML
page, scrapes it for used resources, parses its cache manifest, and validates
the resources against the manifest:$ check_manifest URLProblems with the manifest are written to the standard output.  More detail
about the process is output if you set the log level to a different severity
with the –level=LEVEL switch, where LEVEL is DEBUG, INFO, WARNING, or ERROR.Programmatic useCaveman has been designed to be usable from your own code, for example, as
part of a larger validation process, or as part of unit tests in your web
application.Caveman’s work is done by theManifestCheckerclass.  You instantiate it
with two helpers: aget_urlfunction that fetches data from URLs, and aloggerobject that gets logged messages:from caveman import ManifestChecker

def get_url(url): ...

logger = ...

man_checker = ManifestChecker(get_url=get_url, logger=logger)Then call itscheck_manifestmethod with the URL of the HTML page:man_checker.check_manifest(url)No value is returned: the output has been logged to the logger object.
See the docstrings in the source code for details.Django unit testsAs an example of programmatic use, here’s one way to use Caveman in a Django
test suite:from caveman import ManifestChecker

class TestManifest(django.test.TestCase):
    def setUp(self):
        self.checker = ManifestChecker(get_url=self.get_url, logger=self)
        self.caveman_log = []

    def get_url(self, url):
        """A get_url function for `caveman.ManifestChecker`."""
        # Use the Django test client to fetch the URL.
        response = self.client.get(url)
        return response.status_code, response.content, response

    # Record the serious Caveman messages in `self.caveman_log`.
    def debug(self, msg):       pass
    def info(self, msg):        pass
    def warning(self, msg):     self.caveman_log.append(msg)
    def error(self, msg):       self.caveman_log.append(msg)

    def test_my_manifest(self):
        """Caveman produces no warnings or errors for the cache manifest."""
        self.checker.check_manifest("/")
        self.assertEqual([], self.caveman_log)LimitationsCaveman only pulls the HTML page you specify.  Although it validates links to
other HTML pages against the manifest, it does not pull those linked-to pages
and verify their resources.Certain rules from the HTML5 spec are not validated.More informationCaveman can be downloaded from PyPI:http://pypi.python.org/pypi/cavemanThe HTML5 cache manifest spec is athttp://www.w3.org/TR/html5/offline.htmlDocs athttp://nedbatchelder.com/code/caveman.Code repository and issue tracker are atbitbucket.org.
Package: cavemanstatistics
cavemanstatistics 1.0This package contains unnecessarily slow, brute-force search methods for finding highest R^2 (of linear regression models with specified or unspecified dependant variable) in a dataset. This project is mainly intended to  get to know packaging with pypi.org and to develope my workflow. In the future I'd like to vectorize the loops and maybe add more search options and better search methods. Be careful about combinatorial explosion and set the bounds appropriately.DependanciesNumPyPandasSciPyscikit-learnTabulateInstallingInstall with:pip install cavemanstatisticsQuick documentationThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.After installation, import:fromcavemanstatisticsimportExhaustiveSearch,BruteForceSearch for highest R^2 (unspecified dependant variable):model,results=ExhaustiveSearch(data=pd.dataframe,remove=list,lowerbound=int,upperbound=int,adjusted_R2=bool).solve()y,x=modelprint(model)('depedant variable',[listofexplanatoryvariables])ExhaustiveSearch().solve() returns a touple containing a string (dependant variable) and a list (explanatory variables) and a sorted dictionary with all results.Parameters:data:  has to be a pandas dataframeremove: place list of variable names that you would like to exclude as depedant variables (or place an empty list)lowerbound: smallest integer number of explanatory variables in solution setupperbound: largest integer number of exoplanatory variables in solution setadjusted_R2: True for adjusted R^2, false for R^2Search for highest R^2 (specified dependant variable):model,results=BruteForce(data=pd.dataframe,Y=str,lowerbound=int,upperbound=int,adjusted_R2=bool).solve()y,x=modelprint(model)('depedant variable',[listofexplanatoryvariables])BruteForce().solve() returns a touple containing a string (dependant) and a list (explanatory variables) and a sorted dictionary with all results.Parameters:data:  has to be a pandas dataframeY: the name of the variable that you would like to specify as dependant variablelowerbound: smallest integer number of explanatory variables in solution setupperbound: largest integer number of exoplanatory variables in solution setadjusted_R2: True for adjusted R^2, false for R^2AuthorsGeoffrey Kasenbacher-kgeoffreyLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsThis is a spawn of the frustration caused by the R-Package 'leaps'Tip fedora to the ascii art creators
Package: caveman-stats
cavemanstats!Unnecessarily slow, brute-force search method for highest R^2 of (specified or unspecified) Linear Regression Models.Getting StartedThese instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.PrerequisitesWhat things you need to install the software and how to install themGive examplesInstallingA step by step series of examples that tell you how to get a development env runningSay what the step will bepip install cavemanstatsEnd with an example of getting some data out of the system or using it for a little demoBuilt WithDropwizard- The web framework usedMaven- Dependency ManagementROME- Used to generate RSS FeedsAuthorsGeoffrey Kasenbacher-Initial work-PurpleBoothLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsThis is a spawn of the frustration caused by the R-Package leapsTip my fedora to the ascii art creators