Home	Sort by relevance Sort by last modified time

Full Search Definition Symbol File Path History   | | Help

    Searched refs:Python (Results 126 - 150 of 281) sorted by null

1 2 3 4 56 7 8 91011>>

/device/linaro/bootloader/edk2/BaseTools/Source/C/PyEfiCompressor/
EfiCompressor.c	15 #include <Python.h> 55 // Because some Python objects which support "buffer" protocol have more than one 132 // Because some Python objects which support "buffer" protocol have more than one
/external/autotest/client/deps/lansim/src/
wrapper_linux_if.c	28 #include <Python.h>
/external/python/cpython2/Doc/includes/
noddy3.c	1 #include <Python.h>
noddy4.c	1 #include <Python.h>
/external/python/cpython2/PC/os2emx/
Makefile	3 # Top-Level Makefile for Building Python 2.6 for OS/2 using GCC/EMX 4 # Originally written by Andrew Zabolotny, <bit@eltech.ru> for Python 1.5.2 5 # Modified by Andrew MacIntyre, <andymac@pcug.org.au> for Python 2.6 11 # essential modules of Python and a small Python.exe program to start 12 # the interpreter. When embedding Python within another program, only 15 # python.a and python.lib import libraries. Then the optional 155 SRCPATH=.;../../Python;../../Parser;../../Objects;../../Include;../../Modules 156 # Python contains the central core, containing the builtins and interpreter     [all...]
/external/python/cpython2/Tools/freeze/
checkextensions_win32.py	166 #include "Python.h"
/external/python/cpython3/Doc/includes/
noddy3.c	1 #include <Python.h>
noddy4.c	1 #include <Python.h>
/external/python/cpython3/Tools/freeze/
checkextensions_win32.py	166 #include "Python.h"
/external/tensorflow/tensorflow/contrib/bayesflow/python/ops/
variational_sgd_optimizer.py	19 from tensorflow.python.framework import errors 20 from tensorflow.python.framework import ops 21 from tensorflow.python.ops import array_ops 22 from tensorflow.python.ops import check_ops 23 from tensorflow.python.ops import clip_ops 24 from tensorflow.python.ops import control_flow_ops 25 from tensorflow.python.ops import init_ops 26 from tensorflow.python.ops import math_ops 27 from tensorflow.python.ops import state_ops 28 from tensorflow.python.ops import variable_scope as varscope_op     [all...]
/external/tensorflow/tensorflow/core/profiler/g3doc/
command_line.md	6 * [Profile Python Time](#profile-python-time) 36 ```python 51 ```python 123 ```python 165 #### Profile Python Time 280 First, in Python code, create an `OpLogProto` proto and add op type 283 ```python 295 ```python
python_api.md	0 ## Python API Tutorials 12 ```python 20 # Use code view to associate statistics with Python codes. 39 ``` python 51 ```python 70 ``` python 72 # broken down by python codes. 95 To visualize the result of Python API results: 111 ```python
profile_time.md	4 * [Profile by Python Code](#profile-by-python-code) 40 ### Profile by Python Code 41 ```python 42 # In code view, the time of each line of Python code is the aggregated 97 # It can also be done in Python API 116 ```python 155 ```python 171 ```python
/external/walt/
README.md	35 * Python code used to communicate with WALT from Linux and ChromeOS can be found
/external/webrtc/tools/valgrind-webrtc/
webrtc_tests.bat	13 :: it possible to execute the Python scripts properly. 61 set PYTHONPATH=%THISDIR%..\python\google;%THISDIR%..\valgrind 63 python %THISDIR%webrtc_tests.py %*
/external/tensorflow/tensorflow/tools/docs/
parser.py	15 """Turn Python docstrings into Markdown for TensorFlow documentation.""" 33 from tensorflow.python.util import tf_inspect 36 # A regular expression capturing a python identifier. 76 Documentation files are organized into directories that mirror the python 90 """Get the docs for a given python object. 93 py_object: A python object to retrieve the docs for (class, function/method, 142 py_module_names: A list of string names of Python modules. 232 python name of the object whose documentation page the reference 250 """Resolve a "@{python symbol}" reference to a Markdown link. 284 """Return the master name for a Python symbol name.""     [all...]
/external/tensorflow/tensorflow/python/ops/
init_ops.py	39 from tensorflow.python.framework import constant_op 40 from tensorflow.python.framework import dtypes 41 from tensorflow.python.ops import array_ops 42 from tensorflow.python.ops import linalg_ops 43 from tensorflow.python.ops import math_ops 44 from tensorflow.python.ops import random_ops 45 from tensorflow.python.ops import random_ops 46 from tensorflow.python.util.deprecation import deprecated 47 from tensorflow.python.util.tf_export import tf_export 62 A JSON-serializable Python dict     [all...]
/device/linaro/bootloader/edk2/AppPkg/Applications/Python/Python-2.7.2/Lib/pydoc_data/
topics.py	6 'attribute-access': u'\nCustomizing attribute access\n****************************\n\nThe following methods can be defined to customize the meaning of\nattribute access (use of, assignment to, or deletion of ``x.name``)\nfor class instances.\n\nobject.__getattr__(self, name)\n\n Called when an attribute lookup has not found the attribute in the\n usual places (i.e. it is not an instance attribute nor is it found\n in the class tree for ``self``). ``name`` is the attribute name.\n This method should return the (computed) attribute value or raise\n an ``AttributeError`` exception.\n\n Note that if the attribute is found through the normal mechanism,\n ``__getattr__()`` is not called. (This is an intentional asymmetry\n between ``__getattr__()`` and ``__setattr__()``.) This is done both\n for efficiency reasons and because otherwise ``__getattr__()``\n would have no way to access other attributes of the instance. Note\n that at least for instance variables, you can fake total control by\n not inserting any values in the instance attribute dictionary (but\n instead inserting them in another object). See the\n ``__getattribute__()`` method below for a way to actually get total\n control in new-style classes.\n\nobject.__setattr__(self, name, value)\n\n Called when an attribute assignment is attempted. This is called\n instead of the normal mechanism (i.e. store the value in the\n instance dictionary). *name* is the attribute name, *value* is the\n value to be assigned to it.\n\n If ``__setattr__()`` wants to assign to an instance attribute, it\n should not simply execute ``self.name = value`` --- this would\n cause a recursive call to itself. Instead, it should insert the\n value in the dictionary of instance attributes, e.g.,\n ``self.__dict__[name] = value``. For new-style classes, rather\n than accessing the instance dictionary, it should call the base\n class method with the same name, for example,\n ``object.__setattr__(self, name, value)``.\n\nobject.__delattr__(self, name)\n\n Like ``__setattr__()`` but for attribute deletion instead of\n assignment. This should only be implemented if ``del obj.name`` is\n meaningful for the object.\n\n\nMore attribute access for new-style classes\n===========================================\n\nThe following methods only apply to new-style classes.\n\nobject.__getattribute__(self, name)\n\n Called unconditionally to implement attribute accesses for\n instances of the class. If the class also defines\n ``__getattr__()``, the latter will not be called unless\n ``__getattribute__()`` either calls it explicitly or raises an\n ``AttributeError``. This method should return the (computed)\n attribute value or raise an ``AttributeError`` exception. In order\n to avoid infinite recursion in this method, its implementation\n should always call the base class method with the same name to\n access any attributes it needs, for example,\n ``object.__getattribute__(self, name)``.\n\n Note: This method may still be bypassed when looking up special methods\n as the result of implicit invocation via language syntax or\n built-in functions. See *Special method lookup for new-style\n classes*.\n\n\nImplementing Descriptors\n========================\n\nThe following methods only apply when an instance of the class\ncontaining the method (a so-called *descriptor* class) appears in an\n*owner* class (the descriptor must be in either the owner\'s class\ndictionary or in the class dictionary for one of its parents). In the\nexamples below, "the attribute" refers to the attribute whose name is\nthe key of the property in the owner class\' ``__dict__``.\n\nobject.__get__(self, instance, owner)\n\n Called to get the attribute of the owner class (class attribute\n access) or of an instance of that class (instance attribute\n access). *owner* is always the owner class, while *instance* is the\n instance that the attribute was accessed through, or ``None`` when\n the attribute is accessed through the *owner*. This method should\n return the (computed) attribute value or raise an\n ``AttributeError`` exception.\n\nobject.__set__(self, instance, value)\n\n Called to set the attribute on an instance *instance* of the owner\n class to a new value, *value*.\n\nobject.__delete__(self, instance)\n\n Called to delete the attribute on an instance *instance* of the\n owner class.\n\n\nInvoking Descriptors\n====================\n\nIn general, a descriptor is an object attribute with "binding\nbehavior", one whose attribute access has been overridden by methods\nin the descriptor protocol: ``__get__()``, ``__set__()``, and\n``__delete__()``. If any of those methods are defined for an object,\nit is said to be a descriptor.\n\nThe default behavior for attribute access is to get, set, or delete\nthe attribute from an object\'s dictionary. For instance, ``a.x`` has a\nlookup chain starting with ``a.__dict__[\'x\']``, then\n``type(a).__dict__[\'x\']``, and continuing through the base classes of\n``type(a)`` excluding metaclasses.\n\nHowever, if the looked-up value is an object defining one of the\ndescriptor methods, then Python may override the default behavior and\ninvoke the descriptor method instead. Where this occurs in the\nprecedence chain depends on which descriptor methods were defined and\nhow they were called. Note that descriptors are only invoked for new\nstyle objects or classes (ones that subclass ``object()`` or\n``type()``).\n\nThe starting point for descriptor invocation is a binding, ``a.x``.\nHow the arguments are assembled depends on ``a``:\n\nDirect Call\n The simplest and least common call is when user code directly\n invokes a descriptor method: ``x.__get__(a)``.\n\nInstance Binding\n If binding to a new-style object instance, ``a.x`` is transformed\n into the call: ``type(a).__dict__[\'x\'].__get__(a, type(a))``.\n\nClass Binding\n If binding to a new-style class, ``A.x`` is transformed into the\n call: ``A.__dict__[\'x\'].__get__(None, A)``.\n\nSuper Binding\n If ``a`` is an instance of ``super``, then the binding ``super(B,\n obj).m()`` searches ``obj.__class__.__mro__`` for the base class\n ``A`` immediately preceding ``B`` and then invokes the descriptor\n with the call: ``A.__dict__[\'m\'].__get__(obj, obj.__class__)``.\n\nFor instance bindings, the precedence of descriptor invocation depends\non the which descriptor methods are defined. A descriptor can define\nany combination of ``__get__()``, ``__set__()`` and ``__delete__()``.\nIf it does not define ``__get__()``, then accessing the attribute will\nreturn the descriptor object itself unless there is a value in the\nobject\'s instance dictionary. If the descriptor defines ``__set__()``\nand/or ``__delete__()``, it is a data descriptor; if it defines\nneither, it is a non-data descriptor. Normally, data descriptors\ndefine both ``__get__()`` and ``__set__()``, while non-data\ndescriptors have just the ``__get__()`` method. Data descriptors with\n``__set__()`` and ``__get__()`` defined always override a redefinition\nin an instance dictionary. In contrast, non-data descriptors can be\noverridden by instances.\n\nPython methods (including ``staticmethod()`` and ``classmethod()``)\nare implemented as non-data descriptors. Accordingly, instances can\nredefine and override methods. This allows individual instances to\nacquire behaviors that differ from other instances of the same class.\n\nThe ``property()`` function is implemented as a data descriptor.\nAccordingly, instances cannot override the behavior of a property.\n\n\n__slots__\n=========\n\nBy default, instances of both old and new-style classes have a\ndictionary for attribute storage. This wastes space for objects\nhaving very few instance variables. The space consumption can become\nacute when creating large numbers of instances.\n\nThe default can be overridden by defining *__slots__* in a new-style\nclass definition. The *__slots__* declaration takes a sequence of\ninstance variables and reserves just enough space in each instance to\nhold a value for each variable. Space is saved because *__dict__* is\nnot created for each instance.\n\n__slots__\n\n This class variable can be assigned a string, iterable, or sequence\n of strings with variable names used by instances. If defined in a\n new-style class, *__slots__* reserves space for the declared\n variables and prevents the automatic creation of *__dict__* and\n *__weakref__* for each instance.\n\n New in version 2.2.\n\nNotes on using *__slots__*\n\n* When inheriting from a class without *__slots__*, the *__dict__*\n attribute of that class will always be accessible, so a *__slots__*\n definition in the subclass is meaningless.\n\n* Without a *__dict__* variable, instances cannot be assigned new\n variables not listed in the *__slots__* definition. Attempts to\n assign to an unlisted variable name raises ``AttributeError``. If\n dynamic assignment of new variables is desired, then add\n ``\'__dict__\'`` to the sequence of strings in the *__slots__*\n declaration.\n\n Changed in version 2.3: Previously, adding ``\'__dict__\'`` to the\n *__slots__* declaration would not enable the assignment of new\n attributes not specifically listed in the sequence of instance\n variable names.\n\n* Without a *__weakref__* variable for each instance, classes defining\n *__slots__* do not support weak references to its instances. If weak\n reference support is needed, then add ``\'__weakref__\'`` to the\n sequence of strings in the *__slots__* declaration.\n\n Changed in version 2.3: Previously, adding ``\'__weakref__\'`` to the\n *__slots__* declaration would not enable support for weak\n references.\n\n* *__slots__* are implemented at the class level by creating\n descriptors (*Implementing Descriptors*) for each variable name. As\n a result, class attributes cannot be used to set default values for\n instance variables defined by *__slots__*; otherwise, the class\n attribute would overwrite the descriptor assignment.\n\n* The action of a *__slots__* declaration is limited to the class\n where it is defined. As a result, subclasses will have a *__dict__*\n unless they also define *__slots__* (which must only contain names\n of any *additional* slots).\n\n* If a class defines a slot also defined in a base class, the instance\n variable defined by the base class slot is inaccessible (except by\n retrieving its descriptor directly from the base class). This\n renders the meaning of the program undefined. In the future, a\n check may be added to prevent this.\n\n* Nonempty *__slots__* does not work for classes derived from\n "variable-length" built-in types such as ``long``, ``str`` and\n ``tuple``.\n\n* Any non-string iterable may be assigned to *__slots__*. Mappings may\n also be used; however, in the future, special meaning may be\n assigned to the values corresponding to each key.\n\n* *__class__* assignment works only if both classes have the same\n *__slots__*.\n\n Changed in version 2.6: Previously, *__class__* assignment raised an\n error if either new or old class had *__slots__*.\n', 9 'binary': u'\nBinary arithmetic operations\n****************************\n\nThe binary arithmetic operations have the conventional priority\nlevels. Note that some of these operations also apply to certain non-\nnumeric types. Apart from the power operator, there are only two\nlevels, one for multiplicative operators and one for additive\noperators:\n\n m_expr ::= u_expr | m_expr "*" u_expr | m_expr "//" u_expr | m_expr "/" u_expr\n | m_expr "%" u_expr\n a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr\n\nThe ``*`` (multiplication) operator yields the product of its\narguments. The arguments must either both be numbers, or one argument\nmust be an integer (plain or long) and the other must be a sequence.\nIn the former case, the numbers are converted to a common type and\nthen multiplied together. In the latter case, sequence repetition is\nperformed; a negative repetition factor yields an empty sequence.\n\nThe ``/`` (division) and ``//`` (floor division) operators yield the\nquotient of their arguments. The numeric arguments are first\nconverted to a common type. Plain or long integer division yields an\ninteger of the same type; the result is that of mathematical division\nwith the \'floor\' function applied to the result. Division by zero\nraises the ``ZeroDivisionError`` exception.\n\nThe ``%`` (modulo) operator yields the remainder from the division of\nthe first argument by the second. The numeric arguments are first\nconverted to a common type. A zero right argument raises the\n``ZeroDivisionError`` exception. The arguments may be floating point\nnumbers, e.g., ``3.14%0.7`` equals ``0.34`` (since ``3.14`` equals\n``4*0.7 + 0.34``.) The modulo operator always yields a result with\nthe same sign as its second operand (or zero); the absolute value of\nthe result is strictly smaller than the absolute value of the second\noperand [2].\n\nThe integer division and modulo operators are connected by the\nfollowing identity: ``x == (x/y)*y + (x%y)``. Integer division and\nmodulo are also connected with the built-in function ``divmod()``:\n``divmod(x, y) == (x/y, x%y)``. These identities don\'t hold for\nfloating point numbers; there similar identities hold approximately\nwhere ``x/y`` is replaced by ``floor(x/y)`` or ``floor(x/y) - 1`` [3].\n\nIn addition to performing the modulo operation on numbers, the ``%``\noperator is also overloaded by string and unicode objects to perform\nstring formatting (also known as interpolation). The syntax for string\nformatting is described in the Python Library Reference, section\n*String Formatting Operations*.\n\nDeprecated since version 2.3: The floor division operator, the modulo\noperator, and the ``divmod()`` function are no longer defined for\ncomplex numbers. Instead, convert to a floating point number using\nthe ``abs()`` function if appropriate.\n\nThe ``+`` (addition) operator yields the sum of its arguments. The\narguments must either both be numbers or both sequences of the same\ntype. In the former case, the numbers are converted to a common type\nand then added together. In the latter case, the sequences are\nconcatenated.\n\nThe ``-`` (subtraction) operator yields the difference of its\narguments. The numeric arguments are first converted to a common\ntype.\n', 11 'bltin-code-objects': u'\nCode Objects\n************\n\nCode objects are used by the implementation to represent "pseudo-\ncompiled" executable Python code such as a function body. They differ\nfrom function objects because they don\'t contain a reference to their\nglobal execution environment. Code objects are returned by the built-\nin ``compile()`` function and can be extracted from function objects\nthrough their ``func_code`` attribute. See also the ``code`` module.\n\nA code object can be executed or evaluated by passing it (instead of a\nsource string) to the ``exec`` statement or the built-in ``eval()``\nfunction.\n\nSee *The standard type hierarchy* for more information.\n', 13 'bltin-file-objects': u'\nFile Objects\n************\n\nFile objects are implemented using C\'s ``stdio`` package and can be\ncreated with the built-in ``open()`` function. File objects are also\nreturned by some other built-in functions and methods, such as\n``os.popen()`` and ``os.fdopen()`` and the ``makefile()`` method of\nsocket objects. Temporary files can be created using the ``tempfile``\nmodule, and high-level file operations such as copying, moving, and\ndeleting files and directories can be achieved with the ``shutil``\nmodule.\n\nWhen a file operation fails for an I/O-related reason, the exception\n``IOError`` is raised. This includes situations where the operation\nis not defined for some reason, like ``seek()`` on a tty device or\nwriting a file opened for reading.\n\nFiles have the following methods:\n\nfile.close()\n\n Close the file. A closed file cannot be read or written any more.\n Any operation which requires that the file be open will raise a\n ``ValueError`` after the file has been closed. Calling ``close()``\n more than once is allowed.\n\n As of Python 2.5, you can avoid having to call this method\n explicitly if you use the ``with`` statement. For example, the\n following code will automatically close *f* when the ``with`` block\n is exited:\n\n from __future__ import with_statement # This isn\'t required in Python 2.6\n\n with open("hello.txt") as f:\n for line in f:\n print line\n\n In older versions of Python, you would have needed to do this to\n get the same effect:\n\n f = open("hello.txt")\n try:\n for line in f:\n print line\n finally:\n f.close()\n\n Note: Not all "file-like" types in Python support use as a context\n manager for the ``with`` statement. If your code is intended to\n (…)     [all...]
/device/linaro/bootloader/edk2/BaseTools/
toolsetup.bat	312 echo !!! ERROR !!! Binary python tools are missing. PYTHON_HOME environment variable is not set. 313 echo PYTHON_HOME is required to build or execute the python tools. 319 @REM We have Python, now test for FreezePython application 323 echo Setup environment to run Python scripts directly. 328 set BASETOOLS_PYTHON_SOURCE=%BASE_TOOLS_PATH%\Source\Python 370 echo BUILDING PYTHON TOOLS 373 call nmake python 377 echo !!! WARNING !!! Cannot make executable from Python code, executing python scripts instead !!!
/external/capstone/packages/rpm/
capstone.spec	40 %package python 41 Summary: Python bindings for %{name} 44 %description python 45 The %{name}-python package contains python bindings for %{name}. 76 # build python bindings 77 pushd bindings/python 95 # install python bindings 96 pushd bindings/python 130 %files python     [all...]
/external/libcap-ng/libcap-ng-0.7/
libcap-ng.spec	30 %package python 31 Summary: Python bindings for libcap-ng library 34 BuildRequires: python-devel swig 37 %description python 38 The libcap-ng-python package contains the bindings so that libcap-ng 39 and can be used by python applications. 75 rm -f $RPM_BUILD_ROOT/%{_libdir}/python?.?/site-packages/_capng.a 76 rm -f $RPM_BUILD_ROOT/%{_libdir}/python?.?/site-packages/_capng.la 102 %files python 104 %attr(755,root,root) /%{_libdir}/python?.?/site-packages/_capng.s     [all...]
/external/libyuv/files/tools_libyuv/valgrind/
libyuv_tests.bat	13 :: it possible to execute the Python scripts properly. 77 set PYTHONPATH=%THISDIR%..\python\google;%THISDIR%..\valgrind 79 python %THISDIR%libyuv_tests.py %*
/external/walt/docs/
DragLatency.md	39 The Python script used for ChromeOS employs a 2D extension of this method (implemented in [minimization.py](/pywalt/minimization.py)). This has the opposite requirement of some considerable spread of the collected _x_ coordinates.
/external/golang-protobuf/ptypes/timestamp/
timestamp.pb.go	79 // Example 5: Compute Timestamp from current time in Python. 100 // method. In Python, a standard `datetime.datetime` object can be converted 101 // to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
/external/protobuf/python/google/protobuf/pyext/
message.h	37 #include <Python.h> 62 namespace python { namespace in namespace:google::protobuf 71 // proto tree. Every Python CMessage holds a reference to it in 72 // order to keep it alive as long as there's a Python object that 104 // A reference to a Python dictionary containing CMessage, 107 // Python wrapper for the C++ Message objects on every access, or 135 // The Python DescriptorPool used to create the class. It is needed to resolve 152 // Internal function to create a new empty Message Python object, but with empty 165 // Retrieves the C++ descriptor of a Python Extension descriptor. 201 // Returns a new python reference     [all...]

Completed in 848 milliseconds

1 2 3 4 56 7 8 91011>>