Saravanan666/pypi-org huggingface dataset:
Package: cellular-automata-class
Cell class for Cellular Automatahttps://test.pypi.org/project/cellular-automata-class/Installationpip install cellular-automata-classUsageImport the class as:fromcellular_automata_classimportcellIt can be used to set up a lattice:defset_lattice(length,choice):'''Given the choice of lattice pattern, sets a 2 dimensional, finite lattice,digits of which store a cell each'''lattice=[]forninrange(length):lattice.append([])forxinrange(length):foryinrange(length):lattice[x]+=[Cell(1,x,y)ifx==math.floor(length/2)elseCell(0,x,y)]returnlatticeIn order to "play" the lattice, we need to iterate through the whole lattice callingcell.evaluate()method:defplay(lattice,evaluation_count):forninrange(evaluation_count):lattice_copy=copy.deepcopy(lattice)forxinlattice:foryinx:y.evaluate(lattice_copy)The class can be expanded in various ways. E.g. we can add stochastic element to it, we can add new neighborhood types, etc.TroubleshootingContributeReferences
Package: cellulario
cellulario===========_*Cellular IO - A self-contained and self-managed IO loop*_[![Maturity](https://img.shields.io/pypi/status/cellulario.svg)](https://pypi.python.org/pypi/cellulario)[![License](https://img.shields.io/pypi/l/cellulario.svg)](https://pypi.python.org/pypi/cellulario)[![Change Log](https://img.shields.io/badge/change-log-blue.svg)](https://github.com/mayfield/cellulario/blob/master/CHANGELOG.md)[![Build Status](https://semaphoreci.com/api/v1/projects/3a285086-d1cf-4585-97ec-6b96e707b0c9/595977/shields_badge.svg)](https://semaphoreci.com/mayfield/cellulario)[![Version](https://img.shields.io/pypi/v/cellulario.svg)](https://pypi.python.org/pypi/cellulario)About--------Cellular IO is an interface for IO loop style programming that bundles the IOlooplifecycle into the inner cell of a standard python data interface.  If the cellis used like a generator then the ioloop is managed inside the generator duringcalls to `__next__`.  If callbacks are used then the cell will block the currentexecution context until the sum of IO routines are complete.An IOCell can consist of multiple levels of cascading IO routines.  A first tiermay do requests that add requests of a second tier to the workqueue.  The cellcoordinator keeps track of the different io tiers to ensure they are scheduledaccording to the strategy chosen by the user, be it latency, bandwidth, or justFIFO.Installation--------python3 ./setup.py buildpython3 ./setup.py installCompatibility--------* Python 3.5.3+
Package: celluloid
celluloidEasy Matplotlib AnimationCreating animations should be easy.
This module makes it easy to adapt your existing visualization code to create an animation.Installpip install celluloidManualFollow these steps:Create a matplotlibFigureand create aCamerafrom it:fromcelluloidimportCamerafig=plt.figure()camera=Camera(fig)Reusing the figure and after each frame is created, take a snapshot with the camera.plt.plot(...)plt.fancy_stuff()camera.snap()After all frames have been captured, create the animation.animation=camera.animate()animation.save('animation.mp4')The entiremoduleis less than 50 lines of code.ExamplesMinimalAs simple as it gets.frommatplotlibimportpyplotaspltfromcelluloidimportCamerafig=plt.figure()camera=Camera(fig)foriinrange(10):plt.plot([i]*10)camera.snap()animation=camera.animate()SubplotsAnimation at the top.importnumpyasnpfrommatplotlibimportpyplotaspltfromcelluloidimportCamerafig,axes=plt.subplots(2)camera=Camera(fig)t=np.linspace(0,2*np.pi,128,endpoint=False)foriint:axes[0].plot(t,np.sin(t+i),color='blue')axes[1].plot(t,np.sin(t-i),color='blue')camera.snap()animation=camera.animate()ImagesDomain coloring example.importnumpyasnpfrommatplotlibimportpyplotaspltfrommatplotlib.colorsimporthsv_to_rgbfromcelluloidimportCamerafig=plt.figure()camera=Camera(fig)forainnp.linspace(0,2*np.pi,30,endpoint=False):x=np.linspace(-3,3,800)X,Y=np.meshgrid(x,x)x=X+1j*Yy=(x**2-2.5)*(x-2.5*1j)*(x+2.5*1j)\*(x-2-1j)**2/((x-np.exp(1j*a))**2*(x-np.exp(1j*2*a))**2)H=np.angle(y)/(2*np.pi)+.5r=np.log2(1.+np.abs(y))S=(1.+np.abs(np.sin(2.*np.pi*r)))/2.V=(1.+np.abs(np.cos(2.*np.pi*r)))/2.rgb=hsv_to_rgb(np.dstack((H,S,V)))ax.imshow(rgb)camera.snap()animation=camera.animate()LegendsimportmatplotlibfrommatplotlibimportpyplotaspltfromcelluloidimportCamerafig=plt.figure()camera=Camera(fig)foriinrange(5):t=plt.plot(range(i,i+5))plt.legend(t,[f'line{i}'])camera.snap()animation=camera.animate()LimitationsThe axes' limits should be the same for all plots. The limits of the animation will be the limits of the final plot.Legends will accumulate from previous frames. Pass the artists to thelegendfunction to draw them separately.CreditsInspired byplotnine.
Package: cellxgene-census
CZ CELLxGENE Discover CensusThecellxgene_censuspackage provides an API to facilitate the use of the CZ CELLxGENE Discover Census. For more information about the API and the project visit thechanzuckerberg/cellxgene-census GitHub repo.For More HelpFor more help, please file a issue on the repo, or contact us atsoma@chanzuckerberg.com.If you believe you have found a security issue, we would appreciate notification. Please send email tosecurity@chanzuckerberg.com.
Package: cellygon
cellygoncreate cellular meshes from segmented cellsFree software: GNU General Public License v3Documentation:https://cellygon.readthedocs.io.FeaturesGenerating polygonised cells (cellygons) from segmented cellsOnly epidermal cells are currently supportedCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-07-02)First release on PyPI.
Package: cellyzer
CELLYZERCELLYZERis a python library for CDR(Call Detail Records) data analyzing. I majorly supports 3 type of datasets : Call, Message and Cell/AntennaThis library can be used to easily get user records, connections between users, get population/traffic details using call and cell data etc. Also cellyzer can be used to visualize the population, user home/work locations, user trip/route identification etc.CELLYZER GUIcan be used by even nun-coding people to interact with the library without writing a single line of code.InstallationThe source code is currently hosted on Github athttps://github.com/anjuchamantha/cellyzer---CDR-data-analyzer.Binary installers for the latest released version are available at the Python package index:https://pypi.org/project/cellyzer/Use the package managerpipto install cellyzer.pip install cellyzeror pip3pip3 install cellyzerDependenciesCELLYZERhas some dependencies for calculations and data visualizationxlrd(1.2.0),numpy(1.18.2),tabulate(0.8.7),matplaotlib(3.2.1),networkx(2.4) anddatetime(4.3)folium(0.10.1) for visualizationLicenseThe MIT License (MIT)Copyright (c) 2020 Team CellyzerPermission 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.DocumentationThe official documentation is hosted onhttps://github.com/anjuchamantha/cellyzer---CDR-data-analyzer. It includes a demo, a detailed reference for all functions, and guides on how to useCELLYZER.
Package: cellyzer-gui
CELLYZER GUICELLYZERis a python library for CDR(Call Detail Records) data analyzing. I majorly supports 3 type of datasets : Call, Message and Cell/AntennaThis library can be used to easily get user records, connections between users, get population/traffic details using call and cell data etc. Also cellyzer can be used to visualize the population, user home/work locations, user trip/route identification etc.CELLYZER GUIcan be used by even nun-coding people to interact with the library without writing a single line of code.InstallationThe source code is currently hosted on Github athttps://github.com/anjuchamantha/cellyzer---CDR-data-analyzer.Binary installers for the latest released version are available at the Python package index:https://pypi.org/project/cellyzer/Use the package managerpipto install cellyzer-gui.pip install cellyzer-guior pip3pip3 install cellyzer-guiDependenciesCELLYZER-GUIhas some dependencies for calculations and data visualization"cellyzer >= 1.1.1",
"dash == 1.10.0",
"dash_admin_components == 0.1.4",
"dash_bootstrap_components == 0.9.2",LicenseThe MIT License (MIT)Copyright (c) 2020 Team CellyzerPermission 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.DocumentationThe official documentation is hosted onhttps://anjuchamantha.github.io/cellyzer---CDR-data-analyzer/. It includes a demo, a detailed reference for all functions, and guides on how to useCELLYZER.
Package: cellz
cellzInstallationpip install cellzUsageCellz is an interactive cell interpreter for python. It allows you to run python code from a source file, cell-by-cell: similar to the way we use cells in jupyter notebooks, and all from the command line.Cellz is interactive: you can continue to develop the source code without leaving the interpreter!First split you code into separate cells using the token '#%% cellname'#file.pyimportsys#%% cell1print("hello!")#%% cell2defadd1(x):returnx+1#%% cell3print(add1(5))Then run the file in the cellz interpretercellz file.pyThis will start the interpreter, from which one can run specific cells of code, one at a time.Licensecellzis distributed under the terms of theMITlicense.
Package: celo-etl
Celo ETLCelo ETL lets you convert blockchain data into convenient formats like CSVs and relational databases.Celo ETL is a fork ofQuickstartInstall Celo ETL:pip3installcelo-etlExport blocks and transactions (Schema,Reference):>celoetlexport_blocks_and_transactions--start-block0--end-block100000\--provider-urihttps://alfajores-forno.celo-testnet.org--blocks-outputblocks.csv--transactions-outputtransactions.csvFor the latest version, check out the repo and call>pip3install-e.>python3celoetl.pyRunning Tests>pip3install-e.[dev,streaming]>exportETHEREUM_ETL_RUN_SLOW_TESTS=True
>pytest-vvRunning Tox Tests>pip3installtox
>toxRunning in DockerInstall Dockerhttps://docs.docker.com/install/Build a docker image> docker build -t celo-etl:latest .
 > docker image lsRun a container out of the image> docker run -v $HOME/output:/celo-etl/output celo-etl:latest export_all -s 0 -e 100000 -b 50000 -p https://alfajores-forno.celo-testnet.org
Package: celoMine
celoMineceloMine brings predictive machine learning to your Celonis analyses to enable deep process insights and data-driven decision-making.
This powerful python framework leverage machine learning algorithms and visualization techniques within your Celonis analyses to drive process optimization.Source code:https://github.com/JeanBertinR/celoMineBug reports:https://github.com/JeanBertinR/celoMine/issuesReport a security vulnerability:https://tidelift.com/docs/securityRequirementsPython 3.xpandasscikit-learnmatplotlibInstallationYou can install theceloMinepackage usingpip. Here's the installation command from your terminal:pipinstallceloMineMake sure you have Python and pip installed on your system before running this command.
After the installation, you can import the package in your Python code using the following line:importceloMineThat's all it takes to install the package and import it into your project.UsageAnalyzing Event LogsTheAnalyseEventLogclass allows you to preprocess and analyze event log data. Here is an example of how to use it:fromanalyse_event_logimportAnalyseEventLog# Create an instance of AnalyseEventLoglog_analyzer=AnalyseEventLog()# Load event log data from a CSV filelog_analyzer.load_data('event_log.csv')# Preprocess the datalog_analyzer.preprocess_data()# Train a machine learning modellog_analyzer.train_model()# Get the accuracy of the modelaccuracy=log_analyzer.get_model_accuracy()# Visualize the event log datalog_analyzer.visualize_data()Visualizing Event LogsTheVisualizeEventLogclass allows you to visualize event log data. Here is an example of how to use it:fromvisualize_event_logimportVisualizeEventLog# Create an instance of VisualizeEventLoglog_visualizer=VisualizeEventLog()# Load event log data from a CSV filelog_visualizer.load_data('event_log.csv')# Plot the frequency of events over timelog_visualizer.plot_event_frequency()# Plot the distribution of events by categorylog_visualizer.plot_event_category_distribution()ContributingContributions are welcome! If you have any suggestions or find any issues, please open an issue or submit a pull request.LicenseThis project is licensed under the GPL v3 License.
Package: celox
Celox – an aiohttp-esque HTTP/1.1 client built with trioA minimalistic, fast and straightforward HTTP/1.1 client built usingtrioas a backend.Syntax is similair toaiohttpandrequests.FeaturesGET, HEAD, POST, PUT, PATCH, DELETE methodsHTTP & HTTPS proxiesTimeoutsCookie handlingAiohttp-esque response body streaming.Disable SSL/TLS verificationConnection cachingTable of contentsQuickstartAPI OverviewDependenciesContributingLicenseQuickstartInstall celoxpip install celoxHave fun 🥳importtrioimportceloxasyncdefmain():asyncwithcelox.Client()asclient:asyncwithclient.get("https://httpbin.org/")asresp:body=awaitresp.read()print(body)print(resp)trio.run(main)For more examples take a lookhereAPI OverviewTODODependenciestriomultidictyarlattrsContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.LicenseMIT
Package: celstash
# celstashCelery logging to logstash and sturctured log (JSON) filePlease submit bugs [here](https://github.com/CyberInt/celstash/issues).# Usageimport celstashimport logginglogger = celstash.new_logger('worker1', logstash_host='example.com')logger.setLevel(logging.INFO)logger.info('Money is the root of all evil, and man needs roots.')# logstash setupinput {udp {codec => json}}output {elasticsearch {host => localhost  # Change to your host}}# LicenseMIT, see [LICENSE.txt](LICENSE.txt)
Package: celsus-colendi
Welcome to Colendi Data Team Package 👋The project is used by Colendi Data Team daily code cycle.🏠Homepage of Company🏠Documentation PageArchitectureInstallpipinstallcensus-colendiorpip3installcensus-colendiThese packages need to be downloaded for the project to run.pandas==1.5.1setuptools==65.6.3Werkzeug==2.2.2🤝 ContributingContributions, issues and feature requests are welcome!Fork this repositoryClone to the local machineCreate a branch and make changesCommit changes with clear explanationPush changes to GithubOpen a Pull RequestDon't Forget these by contributing:master branch is the production branch.beta branch is used for the stage environment.alpha branch is used for project development.🔧 Issues & FeedbackFeel free to submit issues and enhancement requestsemail:datateam@colendi.com.
Package: celtic_lib
This module contains a thin wrapper around the CELTIC service which
allows for cross-platform LTI validation.DependenciesrequestsTeststoxis used as a test runner for this library. It is configured to
run tests for py27, py35 and py36.pip install tox
toxUsagefrom celtic_lib import get_lti_validator, LTIValidatorException

LTI_LISTEN_LOCATION = "https://localhost:8000/lti"

def handle_request(request):
    """
        request contains some LTI payload you just received in your application
    """

    app_key = "some_long_unique_string_unique_to_this_application"
    celtic_service_uri = "https://location_of_celtic_service.net/"

    lti_validator = get_lti_validator(celtic_service_uri, app_key)

    http_method = request.method # Will be "POST", since we are only listening on the POST endpoint
    try:
        status, result = lti_validator.validate_request(LTI_LISTEN_LOCATION, http_method, request.POST)
        return print("Request is valid and can be trusted")
    except LTIValidatorException as e:
        return print("Request failed:", e.message, "|", e.status_code)

# router is an imaginary application router.
#   For purposes of this is makes the handle_lti_request function handle all POST requests which are directed at LTI_LISTEN_LOCATION
router.on(LTI_LISTEN_LOCATION, "POST", handle_lti_request)ArchitectureThis module is fairly straightforward, it forwards any LTI request to a
secure endpoint which contains a record of theoauth_consumer_keyand thesecret_key. This remote endpoint then validates the request,
and returns a simple response indicating its validity.DataRequesterThis class exposes apostmethod which takes the
CELTIC service endpoint, and the POST data to send it. It returns the
CELTIC response wrapped in the following interface:* status_code<int>
* json()<dict>The primary reason of this class is to allow users to swap out the
defaultDataRequesterfor their own to provide better control over
the applicationLTIValidatorA class which handles the plumbing of the LTI
validation. It is given a CELTIC service URI, anapp_key, and aDataRequesterinstance. The user then only needs to call thevalidate_requestmethod with a forwarded LTI payload to determine
the validity of it.LTIValidatorExceptionAn exception thrown when the server returns a
not-good error code about the LTI response. The exception exposes the
following data:* message<string> - The error message the CELTIC server responded with
* status_code<int> - The HTTP status code the CELTIC server responded with
* errors<dict> - The response body the CELTIC service responded withDevelopingTo make improvements to this package, the following is required:* A python environment
* [pandoc](https://pandoc.org/installing.html) is used to convert this README.md into `reStructuredText`
    1. First: pip install pypandoc
    2. Second: Download installer from pandoc website
Package: cem
cem: Coarsened Exact Matching for Causal Inferencecemis a lightweight library for Coarsened Exact Matching (CEM). CEM is a matching technique used to reduce covariate imbalance, which would otherwise lead to treatment effect estimates that are sensitive to model specification. By removing and/or reweighting certain observations via CEM, one can arrive at treatment effect estimates that are more stable than those found using other matching techniques like propensity score matching. The L1 and L2 multivariate imbalance measures are implemented as described in [2].UsageLoad the datafromcem.matchimportmatchfromcem.coarsenimportcoarsenfromcem.imbalanceimportL1importstatsmodels.apiassmboston=load_boston()O="MEDV"# outcome variableT="CHAS"# treatment variabley=boston[O]X=boston.drop(columns=O)CRIMZNINDUSCHASNOXRMAGEDISRADTAXPTRATIOBLSTATMEDV00.00632182.3100.5386.57565.24.09129615.3396.94.982410.0273107.0700.4696.42178.94.9671224217.8396.99.1421.620.0272907.0700.4697.18561.14.9671224217.8392.834.0334.730.0323702.1800.4586.99845.86.0622322218.7394.632.9433.440.0690502.1800.4587.14754.26.0622322218.7396.95.3336.2Automatic CoarseningFirst we coarsen the data in an automatic fashion to get a baseline imbalance. Be sure to drop the column containing your outcome variable prior to coarsening/matching.coarsenoptionally takes a list of columns you'd like to auto-coarsen, ignoring the rest.# coarsen predictor variablesX_coarse=coarsen(X,T,"l1")# match observationsweights=match(X_coarse,T)# calculate weighted imbalanceL1(X_coarse,weights)Informed CoarseningIt's recommended to coarsen usingpandas.cutandpandas.qcut, but you are free to coarsen your predictor variables however you wish.# coarsen predictor variablesschema={'CRIM':(pd.cut,{'bins':4}),'ZN':(pd.qcut,{'q':4}),'INDUS':(pd.qcut,{'q':4}),'NOX':(pd.cut,{'bins':5}),'RM':(pd.cut,{'bins':5}),'AGE':(pd.cut,{'bins':5}),'DIS':(pd.cut,{'bins':5}),'RAD':(pd.cut,{'bins':6}),'TAX':(pd.cut,{'bins':5}),'PTRATIO':(pd.cut,{'bins':6}),'B':(pd.cut,{'bins':5}),'LSTAT':(pd.cut,{'bins':5})}X_coarse=X.apply(lambdax:schema[x.name][0](x,**schema[x.name][1])ifx.nameinschemaelsex)# match observationsweights=match(X_coarse,T)# calculate weighted imbalanceL1(X_coarse,weights)# perform weighted regressionmodel=sm.WLS(y,sm.add_constant(X),weights=weights)References[1] Porro, Giuseppe & King, Gary & Iacus, Stefano. (2009). CEM: Software for Coarsened Exact Matching. Journal of Statistical Software. 30. 10.18637/jss.v030.i09.[2] Iacus, S. M., King, G., and Porro, G. Multivariate matching methods that are monotonic imbalance bounding. Journal of the American Statistical Association 106, 493 (2011 2011), 345–361.[3] Iacus, S. M., King, G., and Porro, G. Causal inference without balance checking: Coarsened exact matching. Political Analysis 20, 1 (2012), 1–24.[4] King, G., and Zeng, L. The dangers of extreme counterfactuals. Political Analysis 14 (2006), 131–159.[5] Ho, D., Imai, K., King, G., and Stuart, E. Matching as nonparametric preprocessing for reducing model dependence in parametric causal inference. Political Analysis 15 (2007), 199–236.
Package: cemba-data
**    **     **        *******
//**  **     ****      /**////**
 //****     **//**     /**   /**
  //**     **  //**    /*******
   /**    **********   /**////
   /**   /**//////**   /**
   /**   /**     /**   /**
   //    //      //    //YAP (Yet Another Pipeline)Pipeline(s) for mapping and cluster-level aggregation of single nucleus methylome and multi-omic datasets.
Technologies supported:snmC-seq(1/2/3)snmCT-seq (mC + RNA)snmC2T-seq (mC + RNA + Chromatin Accessibility)snm3C-seq (mC + Chromatin Conformation)any NOMe treated version of the aboveSee Documentation
Package: cemd-metasurf
cemd_metasurfCoupled electric and magnetic dipole (CEMD) librery for calculating optical properties of metasurfaces.Installationpip install cemd-metasurfThe current version can calculate reflexion and transmision for lattices with one particle per unit cell. In future releases it is planning to add new functionalities as:More than one particles per unit cell.Near field calculation (with periodicity along the lattice).Local density of states and near field for dipole exitation.Presence of layered ubstrate.For any comment feel free to contact me!drabujetas@gmail.com